From 4635586a6702b09de03a7ecbe662784a7ae96a5c Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Thu, 7 Nov 2024 14:54:01 +0000
Subject: [PATCH 1/3] Update scalafmt-core to 3.8.3

---
 .scalafmt.conf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.scalafmt.conf b/.scalafmt.conf
index 243e75f0e..8184276d0 100644
--- a/.scalafmt.conf
+++ b/.scalafmt.conf
@@ -1,4 +1,4 @@
-version = "3.6.1"
+version = "3.8.3"
 style = default
 
 maxColumn = 100

From 45112b9ff729c0b774bed69b9d1bcaa99e3873f4 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Thu, 7 Nov 2024 14:54:39 +0000
Subject: [PATCH 2/3] Reformat with scalafmt 3.8.3

Executed command: scalafmt --non-interactive
---
 build.sbt                                     |   2 +-
 .../main/scala/java/util/SimpleTimeZone.scala |   4 +-
 .../src/main/scala/java/util/TimeZone.scala   |   6 +-
 .../bp/chrono/JapaneseChronology.scala        |  16 +-
 .../org/threeten/bp/chrono/JapaneseDate.scala |  24 +-
 .../org/threeten/bp/chrono/JapaneseEra.scala  |  12 +-
 .../bp/chrono/internal/TTBPJapaneseEra.scala  |   4 +-
 .../main/scala/java/util/SimpleTimeZone.scala |   4 +-
 .../src/main/scala/java/util/TimeZone.scala   |   6 +-
 .../scala-2/org/threeten/bp/DayOfWeek.scala   |  33 ++-
 .../main/scala-2/org/threeten/bp/Month.scala  |  50 ++--
 .../org/threeten/bp/chrono/HijrahEra.scala    |   2 +-
 .../org/threeten/bp/chrono/IsoEra.scala       |   6 +-
 .../org/threeten/bp/chrono/MinguoEra.scala    |   6 +-
 .../TTBPDateTimeFormatterBuilder.scala        |   8 +-
 .../threeten/bp/temporal/ChronoField.scala    |  26 +-
 .../org/threeten/bp/temporal/ChronoUnit.scala |  10 +-
 .../org/threeten/bp/temporal/IsoFields.scala  |  28 +-
 .../threeten/bp/temporal/JulianFields.scala   |  10 +-
 .../org/threeten/bp/zone/ZoneMap.scala        |   4 +-
 .../bp/zone/ZoneOffsetTransitionRule.scala    |   6 +-
 .../scala-3/org/threeten/bp/DayOfWeek.scala   |  33 ++-
 .../main/scala-3/org/threeten/bp/Month.scala  |  50 ++--
 .../org/threeten/bp/chrono/HijrahEra.scala    |   2 +-
 .../org/threeten/bp/chrono/IsoEra.scala       |   6 +-
 .../org/threeten/bp/chrono/MinguoEra.scala    |   6 +-
 .../TTBPDateTimeFormatterBuilder.scala        |   8 +-
 .../threeten/bp/temporal/ChronoField.scala    |  26 +-
 .../org/threeten/bp/temporal/ChronoUnit.scala |  10 +-
 .../org/threeten/bp/temporal/IsoFields.scala  |   4 +-
 .../threeten/bp/temporal/JulianFields.scala   |  10 +-
 .../bp/zone/ZoneOffsetTransitionRule.scala    |   6 +-
 .../main/scala/org/threeten/bp/Clock.scala    |  36 +--
 .../main/scala/org/threeten/bp/Duration.scala | 115 ++++----
 .../main/scala/org/threeten/bp/Instant.scala  | 125 ++++----
 .../scala/org/threeten/bp/LocalDate.scala     | 175 ++++++-----
 .../scala/org/threeten/bp/LocalDateTime.scala | 189 ++++++------
 .../scala/org/threeten/bp/LocalTime.scala     | 142 ++++-----
 .../main/scala/org/threeten/bp/MonthDay.scala |  58 ++--
 .../org/threeten/bp/OffsetDateTime.scala      | 198 ++++++-------
 .../scala/org/threeten/bp/OffsetTime.scala    | 144 ++++-----
 .../main/scala/org/threeten/bp/Period.scala   |  48 +--
 .../src/main/scala/org/threeten/bp/Year.scala | 100 +++----
 .../scala/org/threeten/bp/YearMonth.scala     | 112 +++----
 .../main/scala/org/threeten/bp/ZoneId.scala   |  64 ++--
 .../scala/org/threeten/bp/ZoneOffset.scala    |  40 +--
 .../scala/org/threeten/bp/ZoneRegion.scala    |   2 +-
 .../scala/org/threeten/bp/ZonedDateTime.scala | 279 +++++++++---------
 .../bp/chrono/AbstractChronology.scala        |   2 +-
 .../threeten/bp/chrono/ChronoLocalDate.scala  |  32 +-
 .../bp/chrono/ChronoLocalDateImpl.scala       |  14 +-
 .../bp/chrono/ChronoLocalDateTime.scala       |  14 +-
 .../bp/chrono/ChronoLocalDateTimeImpl.scala   |   2 +-
 .../org/threeten/bp/chrono/ChronoPeriod.scala |  22 +-
 .../threeten/bp/chrono/ChronoPeriodImpl.scala |   2 +-
 .../bp/chrono/ChronoZonedDateTime.scala       |  36 +--
 .../bp/chrono/ChronoZonedDateTimeImpl.scala   |   2 +-
 .../org/threeten/bp/chrono/Chronology.scala   |  67 ++---
 .../threeten/bp/chrono/HijrahChronology.scala |   4 +-
 .../org/threeten/bp/chrono/HijrahDate.scala   |  16 +-
 .../threeten/bp/chrono/IsoChronology.scala    |  18 +-
 .../threeten/bp/chrono/MinguoChronology.scala |   6 +-
 .../org/threeten/bp/chrono/MinguoDate.scala   |  12 +-
 .../bp/chrono/ThaiBuddhistChronology.scala    |   4 +-
 .../threeten/bp/chrono/ThaiBuddhistDate.scala |  12 +-
 .../org/threeten/bp/chrono/package.scala      |   8 +-
 .../threeten/bp/format/DateTimeBuilder.scala  |  10 +-
 .../bp/format/DateTimeFormatter.scala         | 124 ++++----
 .../bp/format/DateTimeFormatterBuilder.scala  | 126 ++++----
 .../SimpleDateTimeFormatStyleProvider.scala   |   2 +-
 .../internal/DateTimePrinterParser.scala      |   2 +-
 .../internal/TTBPDateTimeParseContext.scala   |   6 +-
 .../TTBPSimpleDateTimeTextProvider.scala      |   2 +-
 .../main/scala/org/threeten/bp/package.scala  |   2 +-
 .../org/threeten/bp/temporal/Temporal.scala   |  57 ++--
 .../bp/temporal/TemporalAccessor.scala        |  30 +-
 .../bp/temporal/TemporalAdjuster.scala        |  14 +-
 .../bp/temporal/TemporalAdjusters.scala       |   6 +-
 .../threeten/bp/temporal/TemporalAmount.scala |  17 +-
 .../threeten/bp/temporal/TemporalField.scala  |  36 +--
 .../bp/temporal/TemporalQueries.scala         |  84 +++---
 .../threeten/bp/temporal/TemporalQuery.scala  |  21 +-
 .../threeten/bp/temporal/TemporalUnit.scala   |  23 +-
 .../org/threeten/bp/temporal/ValueRange.scala |  20 +-
 .../org/threeten/bp/temporal/WeekFields.scala |  54 ++--
 .../org/threeten/bp/temporal/package.scala    |  16 +-
 .../bp/zone/ZoneOffsetTransition.scala        |  20 +-
 .../org/threeten/bp/zone/ZoneRules.scala      |  16 +-
 .../threeten/bp/zone/ZoneRulesBuilder.scala   |   4 +-
 .../bp/zone/ZoneRulesInitializer.scala        |   2 +-
 .../threeten/bp/zone/ZoneRulesProvider.scala  |  26 +-
 .../bp/temporal/MockFieldNoValue.scala        |  22 +-
 .../bp/temporal/MockFieldNoValue.scala        |  22 +-
 .../org/threeten/bp/AssertionsHelper.scala    |  22 +-
 .../org/threeten/bp/MockSimplePeriod.scala    |   4 +-
 .../scala/org/threeten/bp/TestInstant.scala   |  12 +-
 .../org/threeten/bp/TestLocalDateTime.scala   |   4 +-
 .../bp/format/GenTestPrinterParser.scala      |   6 +-
 98 files changed, 1671 insertions(+), 1669 deletions(-)

diff --git a/build.sbt b/build.sbt
index fd83abe4b..57dfca17d 100644
--- a/build.sbt
+++ b/build.sbt
@@ -143,7 +143,7 @@ lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)
   .in(file("core"))
   .settings(commonSettings)
   .settings(
-    name := "scala-java-time",
+    name                                          := "scala-java-time",
     libraryDependencies += ("org.portable-scala" %%% "portable-scala-reflect" % "1.1.3")
       .cross(CrossVersion.for3Use2_13)
   )
diff --git a/core/js/src/main/scala/java/util/SimpleTimeZone.scala b/core/js/src/main/scala/java/util/SimpleTimeZone.scala
index a67b120b5..e85193b6d 100644
--- a/core/js/src/main/scala/java/util/SimpleTimeZone.scala
+++ b/core/js/src/main/scala/java/util/SimpleTimeZone.scala
@@ -1,9 +1,9 @@
 package java.util
 
 class SimpleTimeZone(rawOffset: Int, var ID: String) extends TimeZone {
-  override def getRawOffset  = rawOffset
+  override def getRawOffset            = rawOffset
   /* concrete methods */
-  override def getID: String = ID
+  override def getID: String           = ID
   override def setID(id: String): Unit = ID = id
 
 }
diff --git a/core/js/src/main/scala/java/util/TimeZone.scala b/core/js/src/main/scala/java/util/TimeZone.scala
index 018118c6c..d7b484235 100644
--- a/core/js/src/main/scala/java/util/TimeZone.scala
+++ b/core/js/src/main/scala/java/util/TimeZone.scala
@@ -51,11 +51,11 @@ object TimeZone {
     new SimpleTimeZone(offsetInMillis, timeZone)
   }
 
-  def getDefault: TimeZone = default
+  def getDefault: TimeZone                 = default
   def setDefault(timeZone: TimeZone): Unit = default = timeZone
 
   def getTimeZone(timeZone: String): TimeZone = getTimeZone(ZoneId.of(timeZone))
-  def getTimeZone(zoneId: ZoneId): TimeZone = {
+  def getTimeZone(zoneId: ZoneId): TimeZone   = {
     val rules          = zoneId.getRules
     val offsetInMillis = rules.getStandardOffset(Instant.now).getTotalSeconds * 1000
     new SimpleTimeZone(offsetInMillis, zoneId.getId)
@@ -80,7 +80,7 @@ abstract class TimeZone extends Serializable with Cloneable {
   // def useDaylightTime: Boolean
 
   /* concrete methods */
-  def getID: String = ID
+  def getID: String           = ID
   def setID(id: String): Unit = ID = id
 
   def getDisplayName(daylight: Boolean, style: Int, locale: Locale): String = {
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala
index 8ac84a894..0cb11812b 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala
@@ -141,8 +141,8 @@ final class JapaneseChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'Japanese'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@code Chronology} . It can be used to lookup the {@code
+   * Chronology} using {@link #of(String)} .
    *
    * @return
    *   the chronology ID - 'Japanese'
@@ -194,7 +194,7 @@ final class JapaneseChronology private () extends Chronology with Serializable {
    * @throws DateTimeException
    *   if unable to create the date
    * @throws ClassCastException
-   *   if the { @code era} is not a { @code JapaneseEra}
+   *   if the {@code era} is not a {@code JapaneseEra}
    */
   override def dateYearDay(era: Era, yearOfEra: Int, dayOfYear: Int): JapaneseDate =
     if (!era.isInstanceOf[JapaneseEra]) throw new ClassCastException("Era must be JapaneseEra")
@@ -276,16 +276,16 @@ final class JapaneseChronology private () extends Chronology with Serializable {
   /**
    * Returns the calendar system era object from the given numeric value.
    *
-   * See the description of each Era for the numeric values of: {@link JapaneseEra#HEISEI}, {@link
-   * JapaneseEra#SHOWA},{@link JapaneseEra#TAISHO}, {@link JapaneseEra#MEIJI}), only Meiji and later
-   * eras are supported.
+   * See the description of each Era for the numeric values of: {@link JapaneseEra#HEISEI} , {@link
+   * JapaneseEra#SHOWA},{@link JapaneseEra#TAISHO}, {@link JapaneseEra#MEIJI} ), only Meiji and
+   * later eras are supported.
    *
    * @param eraValue
    *   the era value
    * @return
-   *   the Japanese { @code Era} for the given numeric era value
+   *   the Japanese {@code Era} for the given numeric era value
    * @throws DateTimeException
-   *   if { @code eraValue} is invalid
+   *   if {@code eraValue} is invalid
    */
   def eraOf(eraValue: Int): JapaneseEra = JapaneseEra.of(eraValue)
 
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala
index 8afc77eaa..2b5b0f13b 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala
@@ -89,7 +89,7 @@ object JapaneseDate {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@linkplain Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -209,20 +209,20 @@ object JapaneseDate {
    *
    * This obtains a date in the Japanese calendar system based on the specified temporal. A {@code
    * TemporalAccessor} represents an arbitrary set of date and time information, which this factory
-   * converts to an instance of {@code JapaneseDate}.
+   * converts to an instance of {@code JapaneseDate} .
    *
    * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code JapaneseDate::from}.
+   * to be used as a query via method reference, {@code JapaneseDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Japanese calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code JapaneseDate}
+   *   if unable to convert to a {@code JapaneseDate}
    */
   def from(temporal: TemporalAccessor): JapaneseDate = JapaneseChronology.INSTANCE.date(temporal)
 
@@ -231,7 +231,7 @@ object JapaneseDate {
 /**
  * A date in the Japanese Imperial calendar system.
  *
- * This date operates using the {@linkplain JapaneseChronology Japanese Imperial calendar}. This
+ * This date operates using the {@linkplain JapaneseChronology Japanese Imperial calendar} . This
  * calendar system is primarily used in Japan.
  *
  * The Japanese Imperial calendar system is the same as the ISO calendar system apart from the
@@ -248,10 +248,10 @@ object JapaneseDate {
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
  * @constructor
- *   Constructs a {@code JapaneseDate}.
+ *   Constructs a {@code JapaneseDate} .
  *
  * This constructor does NOT validate the given parameters, and {@code era} and {@code year} must
- * agree with {@code isoDate}.
+ * agree with {@code isoDate} .
  * @param era
  *   the era, validated not null
  * @param yearOfEra
@@ -307,7 +307,7 @@ final class JapaneseDate private[chrono] (
    * <li>{@code YEAR} <li>{@code ERA} </ul> All other {@code ChronoField} instances will return
    * false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -418,9 +418,9 @@ final class JapaneseDate private[chrono] (
    * @param yearOfEra
    *   the year-of-era to set in the returned date
    * @return
-   *   a { @code JapaneseDate} based on this date with the requested year, never null
+   *   a {@code JapaneseDate} based on this date with the requested year, never null
    * @throws DateTimeException
-   *   if { @code year} is invalid
+   *   if {@code year} is invalid
    */
   private def withYear(era: JapaneseEra, yearOfEra: Int): JapaneseDate = {
     val year: Int = JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra)
@@ -438,9 +438,9 @@ final class JapaneseDate private[chrono] (
    * @param year
    *   the year to set in the returned date
    * @return
-   *   a { @code JapaneseDate} based on this date with the requested year-of-era, never null
+   *   a {@code JapaneseDate} based on this date with the requested year-of-era, never null
    * @throws DateTimeException
-   *   if { @code year} is invalid
+   *   if {@code year} is invalid
    */
   private def withYear(year: Int): JapaneseDate = withYear(getEra, year)
 
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala
index 91f702817..d4ceef0a4 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala
@@ -86,13 +86,13 @@ object JapaneseEra {
    * Obtains an instance of {@code JapaneseEra} from an {@code int} value.
    *
    * The {@link #SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1 Later era
-   * is numbered 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}),
-   * -1 ({@link #MEIJI}), only Meiji and later eras are supported.
+   * is numbered 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}), -1 ({@link
+   * #MEIJI}), only Meiji and later eras are supported.
    *
    * @param japaneseEra
    *   the era to represent
    * @return
-   *   the { @code JapaneseEra} singleton, not null
+   *   the {@code JapaneseEra} singleton, not null
    * @throws DateTimeException
    *   if the value is invalid
    */
@@ -112,7 +112,7 @@ object JapaneseEra {
    * @param japaneseEra
    *   the japaneseEra name; non-null
    * @return
-   *   the { @code JapaneseEra} singleton, never null
+   *   the {@code JapaneseEra} singleton, never null
    * @throws IllegalArgumentException
    *   if there is not JapaneseEra with the specified name
    */
@@ -174,7 +174,7 @@ object JapaneseEra {
  * This class defines the valid eras for the Japanese chronology. Japan introduced the Gregorian
  * calendar starting with Meiji 6. Only Meiji and later eras are supported; dates before Meiji 6,
  * January 1 are not supported. <p> The four supported eras are hard-coded. A single additional era
- * may be registered using {@link #registerEra(LocalDate, String)}.
+ * may be registered using {@link #registerEra(LocalDate, String)} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
@@ -213,7 +213,7 @@ final class JapaneseEra private[chrono] (
   }
 
   /**
-   * Returns the numeric value of this {@code JapaneseEra}.
+   * Returns the numeric value of this {@code JapaneseEra} .
    *
    * The {@link #SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1. Later
    * eras are numbered from 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}) and
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala
index 0506f526b..0ab0ea550 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala
@@ -8,7 +8,7 @@ import java.util.Arrays
 object TTBPJapaneseEra {
 
   /**
-   * Registers an additional instance of {@code JapaneseEra}. <p> A new Japanese era can begin at
+   * Registers an additional instance of {@code JapaneseEra} . <p> A new Japanese era can begin at
    * any time. This method allows one new era to be registered without the need for a new library
    * version. If needed, callers should assign the result to a static variable accessible across the
    * application. This must be done once, in early startup code. <p> NOTE: This method does not
@@ -19,7 +19,7 @@ object TTBPJapaneseEra {
    * @param name
    *   the name
    * @return
-   *   the { @code JapaneseEra} singleton, not null
+   *   the {@code JapaneseEra} singleton, not null
    * @throws DateTimeException
    *   if an additional era has already been registered
    */
diff --git a/core/native/src/main/scala/java/util/SimpleTimeZone.scala b/core/native/src/main/scala/java/util/SimpleTimeZone.scala
index a67b120b5..e85193b6d 100644
--- a/core/native/src/main/scala/java/util/SimpleTimeZone.scala
+++ b/core/native/src/main/scala/java/util/SimpleTimeZone.scala
@@ -1,9 +1,9 @@
 package java.util
 
 class SimpleTimeZone(rawOffset: Int, var ID: String) extends TimeZone {
-  override def getRawOffset  = rawOffset
+  override def getRawOffset            = rawOffset
   /* concrete methods */
-  override def getID: String = ID
+  override def getID: String           = ID
   override def setID(id: String): Unit = ID = id
 
 }
diff --git a/core/native/src/main/scala/java/util/TimeZone.scala b/core/native/src/main/scala/java/util/TimeZone.scala
index 5d172d48e..8dd3cdcc1 100644
--- a/core/native/src/main/scala/java/util/TimeZone.scala
+++ b/core/native/src/main/scala/java/util/TimeZone.scala
@@ -13,11 +13,11 @@ object TimeZone {
     // TODO: implement this functionality, perhaps using https://github.com/scala-native/scala-native/blob/master/posixlib/src/main/scala/scala/scalanative/posix/time.scala
     new SimpleTimeZone(0, "UTC")
 
-  def getDefault: TimeZone = default
+  def getDefault: TimeZone                 = default
   def setDefault(timeZone: TimeZone): Unit = default = timeZone
 
   def getTimeZone(timeZone: String): TimeZone = getTimeZone(ZoneId.of(timeZone))
-  def getTimeZone(zoneId: ZoneId): TimeZone = {
+  def getTimeZone(zoneId: ZoneId): TimeZone   = {
     val rules          = zoneId.getRules
     val offsetInMillis = rules.getStandardOffset(Instant.now).getTotalSeconds * 1000
     new SimpleTimeZone(offsetInMillis, zoneId.getId)
@@ -42,7 +42,7 @@ abstract class TimeZone extends Serializable with Cloneable {
   // def useDaylightTime: Boolean
 
   /* concrete methods */
-  def getID: String = ID
+  def getID: String           = ID
   def setID(id: String): Unit = ID = id
 
   def getDisplayName(daylight: Boolean, style: Int, locale: Locale): String = {
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala b/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala
index c77d2bf23..2e427a426 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala
@@ -60,7 +60,7 @@ import org.threeten.bp.temporal.ValueRange
  * assign different numeric values to the days, declaring Sunday to have the value 1, however this
  * class provides no support for this. See {@link WeekFields} for localized week-numbering.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code DayOfWeek}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code DayOfWeek} . Use
  * {@code getValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
@@ -72,12 +72,13 @@ import org.threeten.bp.temporal.ValueRange
 object DayOfWeek {
 
   /**
-   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@code 1}.
+   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@code 1} .
    */
   lazy val MONDAY = new DayOfWeek("MONDAY", 0)
 
   /**
-   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@code 2}.
+   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@code 2}
+   * .
    */
   lazy val TUESDAY = new DayOfWeek("TUESDAY", 1)
 
@@ -94,7 +95,7 @@ object DayOfWeek {
   lazy val THURSDAY = new DayOfWeek("THURSDAY", 3)
 
   /**
-   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@code 5}.
+   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@code 5} .
    */
   lazy val FRIDAY = new DayOfWeek("FRIDAY", 4)
 
@@ -105,7 +106,7 @@ object DayOfWeek {
   lazy val SATURDAY = new DayOfWeek("SATURDAY", 5)
 
   /**
-   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@code 7}.
+   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@code 7} .
    */
   lazy val SUNDAY = new DayOfWeek("SUNDAY", 6)
 
@@ -147,19 +148,19 @@ object DayOfWeek {
    * Obtains an instance of {@code DayOfWeek} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code DayOfWeek}.
+   * converts the arbitrary temporal object to an instance of {@code DayOfWeek} .
    *
    * The conversion extracts the {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code DayOfWeek::from}.
+   * to be used as a query via method reference, {@code DayOfWeek::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the day-of-week, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code DayOfWeek}
+   *   if unable to convert to a {@code DayOfWeek}
    */
   def from(temporal: TemporalAccessor): DayOfWeek = {
     temporal match {
@@ -221,7 +222,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then this method returns true. All
    * other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -247,7 +248,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -267,7 +268,7 @@ final class DayOfWeek(name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this day-of-week as an {@code int}.
+   * Gets the value of the specified field from this day-of-week as an {@code int} .
    *
    * This queries this day-of-week for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -277,7 +278,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -288,7 +289,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@code int}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -301,7 +302,7 @@ final class DayOfWeek(name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this day-of-week as a {@code long}.
+   * Gets the value of the specified field from this day-of-week as a {@code long} .
    *
    * This queries this day-of-week for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -311,7 +312,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -406,7 +407,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
    * ChronoField#DAY_OF_WEEK} as the field. Note that this adjusts forwards or backwards within a
    * Monday to Sunday week. See {@link WeekFields#dayOfWeek} for localized week start days. See
-   * {@link TemporalAdjusters} for other adjusters with more control, such as {@code next(MONDAY)}.
+   * {@link TemporalAdjusters} for other adjusters with more control, such as {@code next(MONDAY)} .
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/Month.scala b/core/shared/src/main/scala-2/org/threeten/bp/Month.scala
index f6a778cf7..2655da578 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/Month.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/Month.scala
@@ -60,8 +60,8 @@ import org.threeten.bp.temporal.ValueRange
  * is recommended that applications use the enum rather than the {@code int} value to ensure code
  * clarity.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code Month}. Use {@code
- * getValue()} instead.</b>
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code Month} . Use
+ * {@code getValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
  * may be used by any calendar system that has the month-of-year concept defined exactly equivalent
@@ -73,25 +73,25 @@ object Month {
 
   /**
    * The singleton instance for the month of January with 31 days. This has the numeric value of
-   * {@code 1}.
+   * {@code 1} .
    */
   lazy val JANUARY = new Month("JANUARY", 0)
 
   /**
    * The singleton instance for the month of February with 28 days, or 29 in a leap year. This has
-   * the numeric value of {@code 2}.
+   * the numeric value of {@code 2} .
    */
   lazy val FEBRUARY = new Month("FEBRUARY", 1)
 
   /**
    * The singleton instance for the month of March with 31 days. This has the numeric value of
-   * {@code 3}.
+   * {@code 3} .
    */
   lazy val MARCH = new Month("MARCH", 2)
 
   /**
    * The singleton instance for the month of April with 30 days. This has the numeric value of
-   * {@code 4}.
+   * {@code 4} .
    */
   lazy val APRIL = new Month("APRIL", 3)
 
@@ -115,31 +115,31 @@ object Month {
 
   /**
    * The singleton instance for the month of August with 31 days. This has the numeric value of
-   * {@code 8}.
+   * {@code 8} .
    */
   lazy val AUGUST = new Month("AUGUST", 7)
 
   /**
    * The singleton instance for the month of September with 30 days. This has the numeric value of
-   * {@code 9}.
+   * {@code 9} .
    */
   lazy val SEPTEMBER = new Month("SEPTEMBER", 8)
 
   /**
    * The singleton instance for the month of October with 31 days. This has the numeric value of
-   * {@code 10}.
+   * {@code 10} .
    */
   lazy val OCTOBER = new Month("OCTOBER", 9)
 
   /**
    * The singleton instance for the month of November with 30 days. This has the numeric value of
-   * {@code 11}.
+   * {@code 11} .
    */
   lazy val NOVEMBER = new Month("NOVEMBER", 10)
 
   /**
    * The singleton instance for the month of December with 31 days. This has the numeric value of
-   * {@code 12}.
+   * {@code 12} .
    */
   lazy val DECEMBER = new Month("DECEMBER", 11)
 
@@ -191,21 +191,21 @@ object Month {
    * Obtains an instance of {@code Month} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Month}.
+   * converts the arbitrary temporal object to an instance of {@code Month} .
    *
    * The conversion extracts the {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} field. The
    * extraction is only permitted if the temporal object has an ISO chronology, or can be converted
-   * to a {@code LocalDate}.
+   * to a {@code LocalDate} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Month::from}.
+   * to be used in queries via method reference, {@code Month::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the month-of-year, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Month}
+   *   if unable to convert to a {@code Month}
    */
   def from(temporal: TemporalAccessor): Month = {
     var _temporal = temporal
@@ -271,7 +271,7 @@ final class Month private (name: String, ordinal: Int)
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then this method returns true.
    * All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -295,9 +295,9 @@ final class Month private (name: String, ordinal: Int)
    *
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the range of the
    * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -317,7 +317,7 @@ final class Month private (name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this month-of-year as an {@code int}.
+   * Gets the value of the specified field from this month-of-year as an {@code int} .
    *
    * This queries this month for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
@@ -325,9 +325,9 @@ final class Month private (name: String, ordinal: Int)
    *
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
    * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -338,7 +338,7 @@ final class Month private (name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@code int}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -351,16 +351,16 @@ final class Month private (name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this month-of-year as a {@code long}.
+   * Gets the value of the specified field from this month-of-year as a {@code long} .
    *
    * This queries this month for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
    * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala
index 12c9e0686..4516174f2 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala
@@ -79,7 +79,7 @@ object HijrahEra {
  * The Hijrah calendar system has two eras. The date {@code 0001-01-01 (Hijrah)} is {@code 622-06-19
  * (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra} . Use
  * {@code getValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala
index 985490945..f9fe63392 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala
@@ -38,14 +38,14 @@ object IsoEra {
   /**
    * The singleton instance for the era BCE, 'Before Current Era'. The 'ISO' part of the name
    * emphasizes that this differs from the BCE era in the Gregorian calendar system. This has the
-   * numeric value of {@code 0}.
+   * numeric value of {@code 0} .
    */
   lazy val BCE = new IsoEra("BCE", 0)
 
   /**
    * The singleton instance for the era CE, 'Current Era'. The 'ISO' part of the name emphasizes
    * that this differs from the CE era in the Gregorian calendar system. This has the numeric value
-   * of {@code 1}.
+   * of {@code 1} .
    */
   lazy val CE = new IsoEra("CE", 1)
 
@@ -79,7 +79,7 @@ object IsoEra {
  *   - 'Current era' (CE) for years from 0001-01-01 (ISO) and 'Before current era' (BCE) for years
  *     before that.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra} . Use
  * {@code getValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala
index 6014854ba..91dfae9b1 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala
@@ -37,13 +37,13 @@ object MinguoEra {
 
   /**
    * The singleton instance for the era BEFORE_ROC, 'Before Republic of China'. This has the numeric
-   * value of {@code 0}.
+   * value of {@code 0} .
    */
   lazy val BEFORE_ROC = new MinguoEra("BEFORE_ROC", 0)
 
   /**
    * The singleton instance for the era ROC, 'Republic of China'. This has the numeric value of
-   * {@code 1}.
+   * {@code 1} .
    */
   lazy val ROC = new MinguoEra("ROC", 1)
 
@@ -77,7 +77,7 @@ object MinguoEra {
  * The Minguo calendar system has two eras. The date {@code 0001-01-01 (Minguo)} is equal to {@code
  * 1912-01-01 (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra} . Use
  * {@code getValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala b/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
index 77d3e484f..9dc1b0484 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
@@ -282,8 +282,8 @@ object TTBPDateTimeFormatterBuilder {
    * @param signStyle
    *   the positive/negative sign style, not null
    * @param subsequentWidth
-   *   the width of subsequent non-negative numbers, 0 or greater,
-   * -1 if fixed width due to active adjacent parsing
+   *   the width of subsequent non-negative numbers, 0 or greater, -1 if fixed width due to active
+   *   adjacent parsing
    */
   private[format] class NumberPrinterParser private[format] (
     private[format] val field:           TemporalField,
@@ -797,8 +797,8 @@ object TTBPDateTimeFormatterBuilder {
      *
      * The fractional value must be between 0 (inclusive) and 1 (exclusive). It can only be returned
      * if the {@link TemporalField#range() value range} is fixed. The value is obtained by
-     * calculation from the field range and a rounding mode of {@link RoundingMode#FLOOR FLOOR}. The
-     * calculation is inaccurate if the values do not run continuously from smallest to largest.
+     * calculation from the field range and a rounding mode of {@link RoundingMode#FLOOR FLOOR} .
+     * The calculation is inaccurate if the values do not run continuously from smallest to largest.
      *
      * For example, the fractional second-of-minute of 0.25 would be converted to 15, assuming the
      * standard definition of 60 seconds in a minute.
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala
index d460583d4..feb7e462a 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala
@@ -52,7 +52,7 @@ import org.threeten.bp.format.ResolverStyle
  * A standard set of fields.
  *
  * This set of fields provide field-based access to manipulate a date, time or date-time. The
- * standard set of fields can be extended by implementing {@link TemporalField}.
+ * standard set of fields can be extended by implementing {@link TemporalField} .
  *
  * These fields are intended to be applicable in multiple calendar systems. For example, most
  * non-ISO calendar systems define dates as a year, month and day, just with slightly different
@@ -70,7 +70,7 @@ object ChronoField {
    *
    * This field is used to represent the nano-of-second handling any fraction of the second.
    * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * return a value for {@link #SECOND_OF_MINUTE} , {@link #SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should set as much precision as the object
@@ -102,7 +102,7 @@ object ChronoField {
    *
    * This field is used to represent the micro-of-second handling any fraction of the second.
    * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * return a value for {@link #SECOND_OF_MINUTE} , {@link #SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -135,7 +135,7 @@ object ChronoField {
    *
    * This field is used to represent the milli-of-second handling any fraction of the second.
    * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * return a value for {@link #SECOND_OF_MINUTE} , {@link #SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -398,12 +398,12 @@ object ChronoField {
    * The year within the era.
    *
    * This represents the concept of the year within the era. This field is typically used with
-   * {@link #ERA}.
+   * {@link #ERA} .
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@code YEAR} , {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
+   * month and day. These map onto the {@code ERA} , {@code YEAR_OF_ERA} , {@code MONTH_OF_YEAR} and
    * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR} is used depends on which mental
    * model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
    *
@@ -443,9 +443,9 @@ object ChronoField {
    * showing the mapping from proleptic year to year-of-era.
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@code YEAR} , {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
+   * month and day. These map onto the {@code ERA} , {@code YEAR_OF_ERA} , {@code MONTH_OF_YEAR} and
    * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR_OF_ERA} is used depends on which
    * mental model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
    *
@@ -467,7 +467,7 @@ object ChronoField {
    * The era.
    *
    * This represents the concept of the era, which is the largest division of the time-line. This
-   * field is typically used with {@link #YEAR_OF_ERA}.
+   * field is typically used with {@link #YEAR_OF_ERA} .
    *
    * In the default ISO calendar system, there are two eras defined, 'BCE' and 'CE'. The era 'CE' is
    * the one currently in use and year-of-era runs from 1 to the maximum value. The era 'BCE' is the
@@ -508,7 +508,7 @@ object ChronoField {
    * A {@link ZoneOffset} represents the period of time that local time differs from UTC/Greenwich.
    * This is usually a fixed number of hours and minutes. It is equivalent to the {@link
    * ZoneOffset#getTotalSeconds() total amount} of the offset in seconds. For example, during the
-   * winter Paris has an offset of {@code +01:00}, which is 3600 seconds.
+   * winter Paris has an offset of {@code +01:00} , which is 3600 seconds.
    *
    * This field is strictly defined to have the same meaning in all calendar systems. This is
    * necessary to ensure interoperation between calendars.
@@ -619,10 +619,10 @@ final class ChronoField private (
   def checkValidValue(value: Long): Long = _range.checkValidValue(value, this)
 
   /**
-   * Checks that the specified value is valid and fits in an {@code int}.
+   * Checks that the specified value is valid and fits in an {@code int} .
    *
    * This validates that the value is within the outer range of valid values returned by {@link
-   * #range()}. It also checks that all valid values are within the bounds of an {@code int}.
+   * #range()}. It also checks that all valid values are within the bounds of an {@code int} .
    *
    * This method checks against the range of the field in the ISO-8601 calendar system. This range
    * may be incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala
index cd5121774..d68c8f351 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala
@@ -40,7 +40,7 @@ import org.threeten.bp.chrono.ChronoZonedDateTime
  * A standard set of date periods units.
  *
  * This set of units provide unit-based access to manipulate a date, time or date-time. The standard
- * set of units can be extended by implementing {@link TemporalUnit}.
+ * set of units can be extended by implementing {@link TemporalUnit} .
  *
  * These units are intended to be applicable in multiple calendar systems. For example, most non-ISO
  * calendar systems define units of years, months and days, just with slightly different rules. The
@@ -94,7 +94,7 @@ object ChronoUnit {
 
   /**
    * Unit that represents the concept of a day. For the ISO calendar system, it is the standard day
-   * from midnight to midnight. The estimated duration of a day is {@code 24 Hours}.
+   * from midnight to midnight. The estimated duration of a day is {@code 24 Hours} .
    *
    * When used with other calendar systems it must correspond to the day defined by the rising and
    * setting of the Sun on Earth. It is not required that days begin at midnight - when converting
@@ -120,7 +120,7 @@ object ChronoUnit {
 
   /**
    * Unit that represents the concept of a year. For the ISO calendar system, it is equal to 12
-   * months. The estimated duration of a year is {@code 365.2425 Days}.
+   * months. The estimated duration of a year is {@code 365.2425 Days} .
    *
    * When used with other calendar systems it must correspond to an integral number of days or
    * months roughly equal to a year defined by the passage of the Earth around the Sun.
@@ -157,7 +157,7 @@ object ChronoUnit {
   /**
    * Unit that represents the concept of an era. The ISO calendar system doesn't have eras thus it
    * is impossible to add an era to a date or date-time. The estimated duration of the era is
-   * artificially defined as {@code 1,000,000,000 Years}.
+   * artificially defined as {@code 1,000,000,000 Years} .
    *
    * When used with other calendar systems there are no restrictions on the unit.
    */
@@ -166,7 +166,7 @@ object ChronoUnit {
   /**
    * Artificial unit that represents the concept of forever. This is primarily used with {@link
    * TemporalField} to represent unbounded fields such as the year or era. The estimated duration of
-   * the era is artificially defined as the largest duration supported by {@code Duration}.
+   * the era is artificially defined as the largest duration supported by {@code Duration} .
    */
   lazy val FOREVER = new ChronoUnit("Forever", 15, Duration.ofSeconds(Long.MaxValue, 999999999))
 
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala
index 50ac10304..b69c8bfe0 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala
@@ -158,7 +158,7 @@ object IsoFields {
    *
    * This allows a number of week-based-years to be added to, or subtracted from, a date. The unit
    * is equal to either 52 or 53 weeks. The estimated duration of a week-based-year is the same as
-   * that of a standard ISO year at {@code 365.2425 Days}.
+   * that of a standard ISO year at {@code 365.2425 Days} .
    *
    * The rules for addition add the number of week-based-years to the existing value for the
    * week-based-year field. If the resulting week-based-year only has 52 weeks, then the date will
@@ -170,7 +170,7 @@ object IsoFields {
 
   /**
    * Unit that represents the concept of a quarter-year. For the ISO calendar system, it is equal to
-   * 3 months. The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}.
+   * 3 months. The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days} .
    *
    * This unit is an immutable and thread-safe singleton.
    */
@@ -259,13 +259,13 @@ object IsoFields {
     private def QY                 = "QuarterOfYear"
 
     lazy val QUARTER_OF_YEAR: Field = new Field("QUARTER_OF_YEAR", 1) {
-      override def toString: String                          = QY
-      def getBaseUnit: TemporalUnit                          = QUARTER_YEARS
-      def getRangeUnit: TemporalUnit                         = YEARS
-      def range: ValueRange                                  = ValueRange.of(1, 4)
-      def isSupportedBy(temporal: TemporalAccessor): Boolean =
+      override def toString: String                                 = QY
+      def getBaseUnit: TemporalUnit                                 = QUARTER_YEARS
+      def getRangeUnit: TemporalUnit                                = YEARS
+      def range: ValueRange                                         = ValueRange.of(1, 4)
+      def isSupportedBy(temporal: TemporalAccessor): Boolean        =
         temporal.isSupported(MONTH_OF_YEAR) && isIso(temporal)
-      def rangeRefinedBy(temporal: TemporalAccessor): ValueRange = range
+      def rangeRefinedBy(temporal: TemporalAccessor): ValueRange    = range
       def getFrom(temporal: TemporalAccessor): Long                 = {
         if (!temporal.isSupported(this))
           throw unsupportedEx(QY)
@@ -349,13 +349,13 @@ object IsoFields {
       new UnsupportedTemporalTypeException(s"Unsupported field: $f")
 
     lazy val WEEK_BASED_YEAR: Field = new Field("WEEK_BASED_YEAR", 3) {
-      override def toString: String                          = WBY
-      def getBaseUnit: TemporalUnit                          = WEEK_BASED_YEARS
-      def getRangeUnit: TemporalUnit                         = FOREVER
-      def range: ValueRange                                  = YEAR.range
-      def isSupportedBy(temporal: TemporalAccessor): Boolean =
+      override def toString: String                                 = WBY
+      def getBaseUnit: TemporalUnit                                 = WEEK_BASED_YEARS
+      def getRangeUnit: TemporalUnit                                = FOREVER
+      def range: ValueRange                                         = YEAR.range
+      def isSupportedBy(temporal: TemporalAccessor): Boolean        =
         temporal.isSupported(EPOCH_DAY) && isIso(temporal)
-      def rangeRefinedBy(temporal: TemporalAccessor): ValueRange = YEAR.range
+      def rangeRefinedBy(temporal: TemporalAccessor): ValueRange    = YEAR.range
       def getFrom(temporal: TemporalAccessor): Long                 =
         if (!temporal.isSupported(this))
           throw unsupportedEx(WBY)
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala
index 0ef1f8628..b8f4f39e5 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala
@@ -62,7 +62,7 @@ object JulianFields {
    * For date-times, 'JULIAN_DAY.getFrom()' assumes the same value from midnight until just before
    * the next midnight. When 'JULIAN_DAY.adjustInto()' is applied to a date-time, the time of day
    * portion remains unaltered. 'JULIAN_DAY.adjustInto()' and 'JULIAN_DAY.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    *
    * <h3>Astronomical and Scientific Notes</h3> The standard astronomical definition uses a fraction
@@ -94,15 +94,15 @@ object JulianFields {
    *
    * This is an integer-based version of the Modified Julian Day Number. Modified Julian Day (MJD)
    * is a well-known system that counts days continuously. It is defined relative to astronomical
-   * Julian Day as {@code MJD = JD - 2400000.5}. Each Modified Julian Day runs from midnight to
+   * Julian Day as {@code MJD = JD - 2400000.5} . Each Modified Julian Day runs from midnight to
    * midnight. The field always refers to the local date-time, ignoring the offset or zone.
    *
    * For date-times, 'MODIFIED_JULIAN_DAY.getFrom()' assumes the same value from midnight until just
    * before the next midnight. When 'MODIFIED_JULIAN_DAY.adjustInto()' is applied to a date-time,
    * the time of day portion remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and
    * 'MODIFIED_JULIAN_DAY.getFrom()' only apply to {@code Temporal} objects that can be converted
-   * into {@link ChronoField#EPOCH_DAY}. A {@link DateTimeException} is thrown for any other type of
-   * object.
+   * into {@link ChronoField#EPOCH_DAY} . A {@link DateTimeException} is thrown for any other type
+   * of object.
    *
    * This implementation is an integer version of MJD with the decimal part rounded to floor.
    *
@@ -133,7 +133,7 @@ object JulianFields {
    * For date-times, 'RATA_DIE.getFrom()' assumes the same value from midnight until just before the
    * next midnight. When 'RATA_DIE.adjustInto()' is applied to a date-time, the time of day portion
    * remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and 'RATA_DIE.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    */
   lazy val RATA_DIE: TemporalField = Field.RATA_DIE
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala
index f4c6aa966..5e5a4267a 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala
@@ -12,7 +12,7 @@ import scala.collection.immutable
 // TreeMap is not available in Scala.js however it is needed for Time Zone support
 // This is a simple implementation of NavigableMap, performance is likely terrible
 private[bp] class ZoneMap[K: ClassTag, V] private[bp] (var map: immutable.TreeMap[K, V])(implicit
-  ordering:                                                     Ordering[K]
+  ordering: Ordering[K]
 ) extends AbstractMap[K, V]
     with java.util.NavigableMap[K, V] {
   def this()(implicit ordering: Ordering[K]) =
@@ -164,6 +164,6 @@ private[bp] class ZoneMap[K: ClassTag, V] private[bp] (var map: immutable.TreeMa
 object ZoneMap {
 
   def apply[K: ClassTag, V](map: immutable.TreeMap[K, V])(implicit
-    ordering:                    Ordering[K]
+    ordering: Ordering[K]
   ): java.util.NavigableMap[K, V] = new ZoneMap[K, V](map)
 }
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
index c0d2defaf..b7ceff876 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
@@ -60,15 +60,15 @@ object ZoneOffsetTransitionRule {
   /**
    * Obtains an instance defining the yearly rule to create transitions between two offsets.
    *
-   * Applications should normally obtain an instance from {@link ZoneRules}. This factory is only
-   * intended for use when creating {@link ZoneRules}.
+   * Applications should normally obtain an instance from {@link ZoneRules} . This factory is only
+   * intended for use when creating {@link ZoneRules} .
    *
    * @param month
    *   the month of the month-day of the first day of the cutover week, not null
    * @param dayOfMonthIndicator
    *   the day of the month-day of the cutover week, positive if the week is that day or later,
    *   negative if the week is that day or earlier, counting from the last day of the month, from
-   * -28 to 31 excluding 0
+   *   -28 to 31 excluding 0
    * @param dayOfWeek
    *   the required day-of-week, null if the month-day should not be changed
    * @param time
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala b/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala
index 2c4cc0f56..6162303de 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala
@@ -60,7 +60,7 @@ import org.threeten.bp.temporal.ValueRange
  * assign different numeric values to the days, declaring Sunday to have the value 1, however this
  * class provides no support for this. See {@link WeekFields} for localized week-numbering.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code DayOfWeek}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code DayOfWeek} . Use
  * {@code getValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
@@ -100,19 +100,19 @@ object DayOfWeek {
    * Obtains an instance of {@code DayOfWeek} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code DayOfWeek}.
+   * converts the arbitrary temporal object to an instance of {@code DayOfWeek} .
    *
    * The conversion extracts the {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code DayOfWeek::from}.
+   * to be used as a query via method reference, {@code DayOfWeek::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the day-of-week, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code DayOfWeek}
+   *   if unable to convert to a {@code DayOfWeek}
    */
   def from(temporal: TemporalAccessor): DayOfWeek = {
     temporal match {
@@ -136,12 +136,13 @@ enum DayOfWeek(name: String, ordinal: Int)
     with TemporalAdjuster {
 
   /**
-   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@code 1}.
+   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@code 1} .
    */
   case MONDAY extends DayOfWeek("MONDAY", 0)
 
   /**
-   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@code 2}.
+   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@code 2}
+   * .
    */
   case TUESDAY extends DayOfWeek("TUESDAY", 1)
 
@@ -158,7 +159,7 @@ enum DayOfWeek(name: String, ordinal: Int)
   case THURSDAY extends DayOfWeek("THURSDAY", 3)
 
   /**
-   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@code 5}.
+   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@code 5} .
    */
   case FRIDAY extends DayOfWeek("FRIDAY", 4)
 
@@ -169,7 +170,7 @@ enum DayOfWeek(name: String, ordinal: Int)
   case SATURDAY extends DayOfWeek("SATURDAY", 5)
 
   /**
-   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@code 7}.
+   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@code 7} .
    */
   case SUNDAY extends DayOfWeek("SUNDAY", 6)
 
@@ -212,7 +213,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then this method returns true. All
    * other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -238,7 +239,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -258,7 +259,7 @@ enum DayOfWeek(name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this day-of-week as an {@code int}.
+   * Gets the value of the specified field from this day-of-week as an {@code int} .
    *
    * This queries this day-of-week for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -268,7 +269,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -279,7 +280,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@code int}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -292,7 +293,7 @@ enum DayOfWeek(name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this day-of-week as a {@code long}.
+   * Gets the value of the specified field from this day-of-week as a {@code long} .
    *
    * This queries this day-of-week for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -302,7 +303,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -397,7 +398,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
    * ChronoField#DAY_OF_WEEK} as the field. Note that this adjusts forwards or backwards within a
    * Monday to Sunday week. See {@link WeekFields#dayOfWeek} for localized week start days. See
-   * {@link TemporalAdjusters} for other adjusters with more control, such as {@code next(MONDAY)}.
+   * {@link TemporalAdjusters} for other adjusters with more control, such as {@code next(MONDAY)} .
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/Month.scala b/core/shared/src/main/scala-3/org/threeten/bp/Month.scala
index c46abd64f..ea703f864 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/Month.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/Month.scala
@@ -60,8 +60,8 @@ import org.threeten.bp.temporal.ValueRange
  * is recommended that applications use the enum rather than the {@code int} value to ensure code
  * clarity.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code Month}. Use {@code
- * getValue()} instead.</b>
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code Month} . Use
+ * {@code getValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
  * may be used by any calendar system that has the month-of-year concept defined exactly equivalent
@@ -100,21 +100,21 @@ object Month {
    * Obtains an instance of {@code Month} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Month}.
+   * converts the arbitrary temporal object to an instance of {@code Month} .
    *
    * The conversion extracts the {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} field. The
    * extraction is only permitted if the temporal object has an ISO chronology, or can be converted
-   * to a {@code LocalDate}.
+   * to a {@code LocalDate} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Month::from}.
+   * to be used in queries via method reference, {@code Month::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the month-of-year, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Month}
+   *   if unable to convert to a {@code Month}
    */
   def from(temporal: TemporalAccessor): Month = {
     var _temporal = temporal
@@ -143,25 +143,25 @@ enum Month private (name: String, ordinal: Int)
 
   /**
    * The singleton instance for the month of January with 31 days. This has the numeric value of
-   * {@code 1}.
+   * {@code 1} .
    */
   case JANUARY extends Month("JANUARY", 0)
 
   /**
    * The singleton instance for the month of February with 28 days, or 29 in a leap year. This has
-   * the numeric value of {@code 2}.
+   * the numeric value of {@code 2} .
    */
   case FEBRUARY extends Month("FEBRUARY", 1)
 
   /**
    * The singleton instance for the month of March with 31 days. This has the numeric value of
-   * {@code 3}.
+   * {@code 3} .
    */
   case MARCH extends Month("MARCH", 2)
 
   /**
    * The singleton instance for the month of April with 30 days. This has the numeric value of
-   * {@code 4}.
+   * {@code 4} .
    */
   case APRIL extends Month("APRIL", 3)
 
@@ -185,31 +185,31 @@ enum Month private (name: String, ordinal: Int)
 
   /**
    * The singleton instance for the month of August with 31 days. This has the numeric value of
-   * {@code 8}.
+   * {@code 8} .
    */
   case AUGUST extends Month("AUGUST", 7)
 
   /**
    * The singleton instance for the month of September with 30 days. This has the numeric value of
-   * {@code 9}.
+   * {@code 9} .
    */
   case SEPTEMBER extends Month("SEPTEMBER", 8)
 
   /**
    * The singleton instance for the month of October with 31 days. This has the numeric value of
-   * {@code 10}.
+   * {@code 10} .
    */
   case OCTOBER extends Month("OCTOBER", 9)
 
   /**
    * The singleton instance for the month of November with 30 days. This has the numeric value of
-   * {@code 11}.
+   * {@code 11} .
    */
   case NOVEMBER extends Month("NOVEMBER", 10)
 
   /**
    * The singleton instance for the month of December with 31 days. This has the numeric value of
-   * {@code 12}.
+   * {@code 12} .
    */
   case DECEMBER extends Month("DECEMBER", 11)
 
@@ -253,7 +253,7 @@ enum Month private (name: String, ordinal: Int)
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then this method returns true.
    * All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -277,9 +277,9 @@ enum Month private (name: String, ordinal: Int)
    *
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the range of the
    * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -299,7 +299,7 @@ enum Month private (name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this month-of-year as an {@code int}.
+   * Gets the value of the specified field from this month-of-year as an {@code int} .
    *
    * This queries this month for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
@@ -307,9 +307,9 @@ enum Month private (name: String, ordinal: Int)
    *
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
    * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -320,7 +320,7 @@ enum Month private (name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@code int}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -333,16 +333,16 @@ enum Month private (name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this month-of-year as a {@code long}.
+   * Gets the value of the specified field from this month-of-year as a {@code long} .
    *
    * This queries this month for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
    * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala
index 1d28e44d9..54a4461ed 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala
@@ -68,7 +68,7 @@ object HijrahEra {
  * The Hijrah calendar system has two eras. The date {@code 0001-01-01 (Hijrah)} is {@code 622-06-19
  * (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra} . Use
  * {@code getValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala
index 4625e136a..8532e0326 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala
@@ -63,7 +63,7 @@ object IsoEra {
  * \- 'Current era' (CE) for years from 0001-01-01 (ISO) and 'Before current era' (BCE) for years
  * before that.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra} . Use
  * {@code getValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
@@ -73,14 +73,14 @@ enum IsoEra(name: String, ordinal: Int) extends java.lang.Enum[IsoEra] with Era
   /**
    * The singleton instance for the era BCE, 'Before Current Era'. The 'ISO' part of the name
    * emphasizes that this differs from the BCE era in the Gregorian calendar system. This has the
-   * numeric value of {@code 0}.
+   * numeric value of {@code 0} .
    */
   case BCE extends IsoEra("BCE", 0)
 
   /**
    * The singleton instance for the era CE, 'Current Era'. The 'ISO' part of the name emphasizes
    * that this differs from the CE era in the Gregorian calendar system. This has the numeric value
-   * of {@code 1}.
+   * of {@code 1} .
    */
   case CE extends IsoEra("CE", 1)
 
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala
index ce3660ba7..b46e5327c 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala
@@ -63,7 +63,7 @@ object MinguoEra {
  * The Minguo calendar system has two eras. The date {@code 0001-01-01 (Minguo)} is equal to {@code
  * 1912-01-01 (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra}. Use
+ * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra} . Use
  * {@code getValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
@@ -72,13 +72,13 @@ enum MinguoEra(name: String, ordinal: Int) extends java.lang.Enum[MinguoEra] wit
 
   /**
    * The singleton instance for the era BEFORE_ROC, 'Before Republic of China'. This has the numeric
-   * value of {@code 0}.
+   * value of {@code 0} .
    */
   case BEFORE_ROC extends MinguoEra("BEFORE_ROC", 0)
 
   /**
    * The singleton instance for the era ROC, 'Republic of China'. This has the numeric value of
-   * {@code 1}.
+   * {@code 1} .
    */
   case ROC extends MinguoEra("ROC", 1)
 
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala b/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
index 876addf5e..dcc2ca22a 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
@@ -279,8 +279,8 @@ object TTBPDateTimeFormatterBuilder {
    * @param signStyle
    *   the positive/negative sign style, not null
    * @param subsequentWidth
-   *   the width of subsequent non-negative numbers, 0 or greater,
-   * -1 if fixed width due to active adjacent parsing
+   *   the width of subsequent non-negative numbers, 0 or greater, -1 if fixed width due to active
+   *   adjacent parsing
    */
   private[format] class NumberPrinterParser private[format] (
     private[format] val field:           TemporalField,
@@ -794,8 +794,8 @@ object TTBPDateTimeFormatterBuilder {
      *
      * The fractional value must be between 0 (inclusive) and 1 (exclusive). It can only be returned
      * if the {@link TemporalField#range() value range} is fixed. The value is obtained by
-     * calculation from the field range and a rounding mode of {@link RoundingMode#FLOOR FLOOR}. The
-     * calculation is inaccurate if the values do not run continuously from smallest to largest.
+     * calculation from the field range and a rounding mode of {@link RoundingMode#FLOOR FLOOR} .
+     * The calculation is inaccurate if the values do not run continuously from smallest to largest.
      *
      * For example, the fractional second-of-minute of 0.25 would be converted to 15, assuming the
      * standard definition of 60 seconds in a minute.
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala
index 50491e1f9..d1ab915e0 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala
@@ -52,7 +52,7 @@ import org.threeten.bp.format.ResolverStyle
  * A standard set of fields.
  *
  * This set of fields provide field-based access to manipulate a date, time or date-time. The
- * standard set of fields can be extended by implementing {@link TemporalField}.
+ * standard set of fields can be extended by implementing {@link TemporalField} .
  *
  * These fields are intended to be applicable in multiple calendar systems. For example, most
  * non-ISO calendar systems define dates as a year, month and day, just with slightly different
@@ -80,7 +80,7 @@ enum ChronoField private (
    *
    * This field is used to represent the nano-of-second handling any fraction of the second.
    * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * return a value for {@link #SECOND_OF_MINUTE} , {@link #SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should set as much precision as the object
@@ -112,7 +112,7 @@ enum ChronoField private (
    *
    * This field is used to represent the micro-of-second handling any fraction of the second.
    * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * return a value for {@link #SECOND_OF_MINUTE} , {@link #SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -145,7 +145,7 @@ enum ChronoField private (
    *
    * This field is used to represent the milli-of-second handling any fraction of the second.
    * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * return a value for {@link #SECOND_OF_MINUTE} , {@link #SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -414,12 +414,12 @@ enum ChronoField private (
    * The year within the era.
    *
    * This represents the concept of the year within the era. This field is typically used with
-   * {@link #ERA}.
+   * {@link #ERA} .
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@code YEAR} , {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
+   * month and day. These map onto the {@code ERA} , {@code YEAR_OF_ERA} , {@code MONTH_OF_YEAR} and
    * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR} is used depends on which mental
    * model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
    *
@@ -460,9 +460,9 @@ enum ChronoField private (
    * showing the mapping from proleptic year to year-of-era.
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@code YEAR} , {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
+   * month and day. These map onto the {@code ERA} , {@code YEAR_OF_ERA} , {@code MONTH_OF_YEAR} and
    * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR_OF_ERA} is used depends on which
    * mental model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
    *
@@ -484,7 +484,7 @@ enum ChronoField private (
    * The era.
    *
    * This represents the concept of the era, which is the largest division of the time-line. This
-   * field is typically used with {@link #YEAR_OF_ERA}.
+   * field is typically used with {@link #YEAR_OF_ERA} .
    *
    * In the default ISO calendar system, there are two eras defined, 'BCE' and 'CE'. The era 'CE' is
    * the one currently in use and year-of-era runs from 1 to the maximum value. The era 'BCE' is the
@@ -526,7 +526,7 @@ enum ChronoField private (
    * A {@link ZoneOffset} represents the period of time that local time differs from UTC/Greenwich.
    * This is usually a fixed number of hours and minutes. It is equivalent to the {@link
    * ZoneOffset#getTotalSeconds() total amount} of the offset in seconds. For example, during the
-   * winter Paris has an offset of {@code +01:00}, which is 3600 seconds.
+   * winter Paris has an offset of {@code +01:00} , which is 3600 seconds.
    *
    * This field is strictly defined to have the same meaning in all calendar systems. This is
    * necessary to ensure interoperation between calendars.
@@ -630,10 +630,10 @@ enum ChronoField private (
   def checkValidValue(value: Long): Long = _range.checkValidValue(value, this)
 
   /**
-   * Checks that the specified value is valid and fits in an {@code int}.
+   * Checks that the specified value is valid and fits in an {@code int} .
    *
    * This validates that the value is within the outer range of valid values returned by {@link
-   * #range()}. It also checks that all valid values are within the bounds of an {@code int}.
+   * #range()}. It also checks that all valid values are within the bounds of an {@code int} .
    *
    * This method checks against the range of the field in the ISO-8601 calendar system. This range
    * may be incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala
index 1dc0d2b79..ffb362cce 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala
@@ -40,7 +40,7 @@ import org.threeten.bp.chrono.ChronoZonedDateTime
  * A standard set of date periods units.
  *
  * This set of units provide unit-based access to manipulate a date, time or date-time. The standard
- * set of units can be extended by implementing {@link TemporalUnit}.
+ * set of units can be extended by implementing {@link TemporalUnit} .
  *
  * These units are intended to be applicable in multiple calendar systems. For example, most non-ISO
  * calendar systems define units of years, months and days, just with slightly different rules. The
@@ -99,7 +99,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
 
   /**
    * Unit that represents the concept of a day. For the ISO calendar system, it is the standard day
-   * from midnight to midnight. The estimated duration of a day is {@code 24 Hours}.
+   * from midnight to midnight. The estimated duration of a day is {@code 24 Hours} .
    *
    * When used with other calendar systems it must correspond to the day defined by the rising and
    * setting of the Sun on Earth. It is not required that days begin at midnight - when converting
@@ -125,7 +125,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
 
   /**
    * Unit that represents the concept of a year. For the ISO calendar system, it is equal to 12
-   * months. The estimated duration of a year is {@code 365.2425 Days}.
+   * months. The estimated duration of a year is {@code 365.2425 Days} .
    *
    * When used with other calendar systems it must correspond to an integral number of days or
    * months roughly equal to a year defined by the passage of the Earth around the Sun.
@@ -162,7 +162,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
   /**
    * Unit that represents the concept of an era. The ISO calendar system doesn't have eras thus it
    * is impossible to add an era to a date or date-time. The estimated duration of the era is
-   * artificially defined as {@code 1,000,000,000 Years}.
+   * artificially defined as {@code 1,000,000,000 Years} .
    *
    * When used with other calendar systems there are no restrictions on the unit.
    */
@@ -171,7 +171,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
   /**
    * Artificial unit that represents the concept of forever. This is primarily used with {@link
    * TemporalField} to represent unbounded fields such as the year or era. The estimated duration of
-   * the era is artificially defined as the largest duration supported by {@code Duration}.
+   * the era is artificially defined as the largest duration supported by {@code Duration} .
    */
   case FOREVER extends ChronoUnit("Forever", 15, Duration.ofSeconds(Long.MaxValue, 999999999))
 
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala
index 299e569b5..43f2d1c40 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala
@@ -158,7 +158,7 @@ object IsoFields {
    *
    * This allows a number of week-based-years to be added to, or subtracted from, a date. The unit
    * is equal to either 52 or 53 weeks. The estimated duration of a week-based-year is the same as
-   * that of a standard ISO year at {@code 365.2425 Days}.
+   * that of a standard ISO year at {@code 365.2425 Days} .
    *
    * The rules for addition add the number of week-based-years to the existing value for the
    * week-based-year field. If the resulting week-based-year only has 52 weeks, then the date will
@@ -170,7 +170,7 @@ object IsoFields {
 
   /**
    * Unit that represents the concept of a quarter-year. For the ISO calendar system, it is equal to
-   * 3 months. The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}.
+   * 3 months. The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days} .
    *
    * This unit is an immutable and thread-safe singleton.
    */
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala
index f647834c2..c5a404e28 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala
@@ -62,7 +62,7 @@ object JulianFields {
    * For date-times, 'JULIAN_DAY.getFrom()' assumes the same value from midnight until just before
    * the next midnight. When 'JULIAN_DAY.adjustInto()' is applied to a date-time, the time of day
    * portion remains unaltered. 'JULIAN_DAY.adjustInto()' and 'JULIAN_DAY.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    *
    * <h3>Astronomical and Scientific Notes</h3> The standard astronomical definition uses a fraction
@@ -94,15 +94,15 @@ object JulianFields {
    *
    * This is an integer-based version of the Modified Julian Day Number. Modified Julian Day (MJD)
    * is a well-known system that counts days continuously. It is defined relative to astronomical
-   * Julian Day as {@code MJD = JD - 2400000.5}. Each Modified Julian Day runs from midnight to
+   * Julian Day as {@code MJD = JD - 2400000.5} . Each Modified Julian Day runs from midnight to
    * midnight. The field always refers to the local date-time, ignoring the offset or zone.
    *
    * For date-times, 'MODIFIED_JULIAN_DAY.getFrom()' assumes the same value from midnight until just
    * before the next midnight. When 'MODIFIED_JULIAN_DAY.adjustInto()' is applied to a date-time,
    * the time of day portion remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and
    * 'MODIFIED_JULIAN_DAY.getFrom()' only apply to {@code Temporal} objects that can be converted
-   * into {@link ChronoField#EPOCH_DAY}. A {@link DateTimeException} is thrown for any other type of
-   * object.
+   * into {@link ChronoField#EPOCH_DAY} . A {@link DateTimeException} is thrown for any other type
+   * of object.
    *
    * This implementation is an integer version of MJD with the decimal part rounded to floor.
    *
@@ -133,7 +133,7 @@ object JulianFields {
    * For date-times, 'RATA_DIE.getFrom()' assumes the same value from midnight until just before the
    * next midnight. When 'RATA_DIE.adjustInto()' is applied to a date-time, the time of day portion
    * remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and 'RATA_DIE.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    */
   lazy val RATA_DIE: TemporalField = Field.RATA_DIE
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala b/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
index b10b69a5b..f6ae15802 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
@@ -60,15 +60,15 @@ object ZoneOffsetTransitionRule {
   /**
    * Obtains an instance defining the yearly rule to create transitions between two offsets.
    *
-   * Applications should normally obtain an instance from {@link ZoneRules}. This factory is only
-   * intended for use when creating {@link ZoneRules}.
+   * Applications should normally obtain an instance from {@link ZoneRules} . This factory is only
+   * intended for use when creating {@link ZoneRules} .
    *
    * @param month
    *   the month of the month-day of the first day of the cutover week, not null
    * @param dayOfMonthIndicator
    *   the day of the month-day of the cutover week, positive if the week is that day or later,
    *   negative if the week is that day or earlier, counting from the last day of the month, from
-   * -28 to 31 excluding 0
+   *   -28 to 31 excluding 0
    * @param dayOfWeek
    *   the required day-of-week, null if the month-day should not be changed
    * @param time
diff --git a/core/shared/src/main/scala/org/threeten/bp/Clock.scala b/core/shared/src/main/scala/org/threeten/bp/Clock.scala
index ab2228149..df7ae4bf0 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Clock.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Clock.scala
@@ -42,16 +42,16 @@ object Clock {
    * Obtains a clock that returns the current instant using the best available system clock,
    * converting to date and time using the UTC time-zone.
    *
-   * This clock, rather than {@link #systemDefaultZone()}, should be used when you need the current
+   * This clock, rather than {@link #systemDefaultZone()} , should be used when you need the current
    * instant without the date or time.
    *
    * This clock is based on the best available system clock. This may use {@link
    * System#currentTimeMillis()}, or a higher resolution clock if one is available.
    *
-   * Conversion from instant to date or time uses the {@link ZoneOffset#UTC UTC time-zone}.
+   * Conversion from instant to date or time uses the {@link ZoneOffset#UTC UTC time-zone} .
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code system(ZoneOffset.UTC)}.
+   * The returned implementation is immutable, thread-safe and {@code Serializable} . It is
+   * equivalent to {@code system(ZoneOffset.UTC)} .
    *
    * @return
    *   a clock that uses the best available system clock in the UTC zone, not null
@@ -70,8 +70,8 @@ object Clock {
    * #systemUTC() UTC clock} should be used when you need the current instant without the date or
    * time.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code system(ZoneId.systemDefault())}.
+   * The returned implementation is immutable, thread-safe and {@code Serializable} . It is
+   * equivalent to {@code system(ZoneId.systemDefault())} .
    *
    * @return
    *   a clock that uses the best available system clock in the default zone, not null
@@ -88,7 +88,7 @@ object Clock {
    *
    * Conversion from instant to date or time uses the specified time-zone.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}.
+   * The returned implementation is immutable, thread-safe and {@code Serializable} .
    *
    * @param zone
    *   the time-zone to use to convert the instant to date-time, not null
@@ -106,14 +106,14 @@ object Clock {
    *
    * This clock will always have the nano-of-second field set to zero. This ensures that the visible
    * time ticks in whole seconds. The underlying clock is the best available system clock,
-   * equivalent to using {@link #system(ZoneId)}.
+   * equivalent to using {@link #system(ZoneId)} .
    *
    * Implementations may use a caching strategy for performance reasons. As such, it is possible
    * that the start of the second observed via this clock will be later than that observed directly
    * via the underlying clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code tick(system(zone), Duration.ofSeconds(1))}.
+   * The returned implementation is immutable, thread-safe and {@code Serializable} . It is
+   * equivalent to {@code tick(system(zone), Duration.ofSeconds(1))} .
    *
    * @param zone
    *   the time-zone to use to convert the instant to date-time, not null
@@ -128,14 +128,14 @@ object Clock {
    *
    * This clock will always have the nano-of-second and second-of-minute fields set to zero. This
    * ensures that the visible time ticks in whole minutes. The underlying clock is the best
-   * available system clock, equivalent to using {@link #system(ZoneId)}.
+   * available system clock, equivalent to using {@link #system(ZoneId)} .
    *
    * Implementations may use a caching strategy for performance reasons. As such, it is possible
    * that the start of the minute observed via this clock will be later than that observed directly
    * via the underlying clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code tick(system(zone), Duration.ofMinutes(1))}.
+   * The returned implementation is immutable, thread-safe and {@code Serializable} . It is
+   * equivalent to {@code tick(system(zone), Duration.ofMinutes(1))} .
    *
    * @param zone
    *   the time-zone to use to convert the instant to date-time, not null
@@ -198,7 +198,7 @@ object Clock {
    * sense. The main use case for this is in testing, where the fixed clock ensures tests are not
    * dependent on the current clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}.
+   * The returned implementation is immutable, thread-safe and {@code Serializable} .
    *
    * @param fixedInstant
    *   the instant to use as the clock, not null
@@ -378,7 +378,7 @@ object Clock {
  *
  * Instances of this class are used to find the current instant, which can be interpreted using the
  * stored time-zone to find the current date and time. As such, a clock can be used instead of
- * {@link System#currentTimeMillis()} and {@link TimeZone#getDefault()}.
+ * {@link System#currentTimeMillis()} and {@link TimeZone#getDefault()} .
  *
  * Use of a {@code Clock} is optional. All key date-time classes also have a {@code now()} factory
  * method that uses the system clock in the default time zone. The primary purpose of this
@@ -393,7 +393,7 @@ object Clock {
  * to be used during testing.
  *
  * The {@code system} factory methods provide clocks based on the best available system clock This
- * may use {@link System#currentTimeMillis()}, or a higher resolution clock if one is available.
+ * may use {@link System#currentTimeMillis()} , or a higher resolution clock if one is available.
  *
  * <h3>Specification for implementors</h3> This abstract class must be implemented with care to
  * ensure other operate correctly. All implementations that can be instantiated must be final,
@@ -442,12 +442,12 @@ abstract class Clock protected () {
    * Gets the current millisecond instant of the clock.
    *
    * This returns the millisecond-based instant, measured from 1970-01-01T00:00 UTC. This is
-   * equivalent to the definition of {@link System#currentTimeMillis()}.
+   * equivalent to the definition of {@link System#currentTimeMillis()} .
    *
    * Most applications should avoid this method and use {@link Instant} to represent an instant on
    * the time-line rather than a raw millisecond value. This method is provided to allow the use of
    * the clock in high performance use cases where the creation of an object would be unacceptable.
-   * The default implementation currently calls {@link #instant()}.
+   * The default implementation currently calls {@link #instant()} .
    *
    * @return
    *   the current millisecond instant from this clock, measured from the Java epoch of
diff --git a/core/shared/src/main/scala/org/threeten/bp/Duration.scala b/core/shared/src/main/scala/org/threeten/bp/Duration.scala
index fc7eda6ad..67b780818 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Duration.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Duration.scala
@@ -87,9 +87,9 @@ object Duration {
    * @param days
    *   the number of days, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws ArithmeticException
-   *   if the input days exceeds the capacity of { @code Duration}
+   *   if the input days exceeds the capacity of {@code Duration}
    */
   def ofDays(days: Long): Duration = create(Math.multiplyExact(days, 86400L), 0)
 
@@ -102,9 +102,9 @@ object Duration {
    * @param hours
    *   the number of hours, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws ArithmeticException
-   *   if the input hours exceeds the capacity of { @code Duration}
+   *   if the input hours exceeds the capacity of {@code Duration}
    */
   def ofHours(hours: Long): Duration = create(Math.multiplyExact(hours, 3600L), 0)
 
@@ -117,9 +117,9 @@ object Duration {
    * @param minutes
    *   the number of minutes, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws ArithmeticException
-   *   if the input minutes exceeds the capacity of { @code Duration}
+   *   if the input minutes exceeds the capacity of {@code Duration}
    */
   def ofMinutes(minutes: Long): Duration = create(Math.multiplyExact(minutes, 60L), 0)
 
@@ -131,7 +131,7 @@ object Duration {
    * @param seconds
    *   the number of seconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    */
   def ofSeconds(seconds: Long): Duration = create(seconds, 0)
 
@@ -150,9 +150,9 @@ object Duration {
    * @param nanoAdjustment
    *   the nanosecond adjustment to the number of seconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws ArithmeticException
-   *   if the adjustment causes the seconds to exceed the capacity of { @code Duration}
+   *   if the adjustment causes the seconds to exceed the capacity of {@code Duration}
    */
   def ofSeconds(seconds: Long, nanoAdjustment: Long): Duration = {
     val secs: Long = Math.addExact(seconds, Math.floorDiv(nanoAdjustment, NANOS_PER_SECOND.toLong))
@@ -168,7 +168,7 @@ object Duration {
    * @param millis
    *   the number of milliseconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    */
   def ofMillis(millis: Long): Duration = {
     var secs: Long = millis / 1000
@@ -188,7 +188,7 @@ object Duration {
    * @param nanos
    *   the number of nanoseconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    */
   def ofNanos(nanos: Long): Duration = {
     var secs: Long = nanos / NANOS_PER_SECOND
@@ -214,7 +214,7 @@ object Duration {
    * @param unit
    *   the unit that the duration is measured in, must have an exact duration, not null
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws DateTimeException
    *   if the period unit has an estimated duration
    * @throws ArithmeticException
@@ -236,7 +236,7 @@ object Duration {
    * @param amount
    *   the amount to convert, not null
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws DateTimeException
    *   if the amount cannot be converted
    * @throws ArithmeticException
@@ -258,7 +258,7 @@ object Duration {
    *
    * Obtains a {@code Duration} representing the duration between two instants. This calculates the
    * duration between two temporal objects of the same type. The difference in seconds is calculated
-   * using {@link Temporal#until(Temporal, TemporalUnit)}. The difference in nanoseconds is
+   * using {@link Temporal#until(Temporal, TemporalUnit)} . The difference in nanoseconds is
    * calculated using by querying the {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} field.
    *
    * The result of this method can be a negative period if the end is before the start. To guarantee
@@ -269,11 +269,11 @@ object Duration {
    * @param endExclusive
    *   the end instant, exclusive, not null
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws DateTimeException
    *   if the seconds between the temporals cannot be obtained
    * @throws ArithmeticException
-   *   if the calculation exceeds the capacity of { @code Duration}
+   *   if the calculation exceeds the capacity of {@code Duration}
    */
   def between(startInclusive: Temporal, endExclusive: Temporal): Duration = {
     var secs: Long  = startInclusive.until(endExclusive, SECONDS)
@@ -298,7 +298,7 @@ object Duration {
   }
 
   /**
-   * Obtains a {@code Duration} from a text string such as {@code PnDTnHnMn.nS}.
+   * Obtains a {@code Duration} from a text string such as {@code PnDTnHnMn.nS} .
    *
    * This will parse a textual representation of a duration, including the string produced by {@code
    * toString()}. The formats accepted are based on the ISO-8601 duration format {@code
@@ -313,7 +313,7 @@ object Duration {
    * sections must be present, and if "T" is present there must be at least one section after the
    * "T". The number part of each section must consist of one or more ASCII digits. The number may
    * be prefixed by the ASCII negative or positive symbol. The number of days, hours and minutes
-   * must parse to a {@code long}. The number of seconds must parse to a {@code long} with optional
+   * must parse to a {@code long} . The number of seconds must parse to a {@code long} with optional
    * fraction. The decimal point may be either a dot or a comma. The fractional part may have from
    * zero to 9 digits.
    *
@@ -452,7 +452,7 @@ object Duration {
    * @param seconds
    *   the number of seconds, up to scale 9, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@code Duration} , not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -475,11 +475,11 @@ object Duration {
  * daylight savings effects. See {@link Period} for the date-based equivalent to this class.
  *
  * A physical duration could be of infinite length. For practicality, the duration is stored with
- * constraints similar to {@link Instant}. The duration uses nanosecond resolution with a maximum
- * value of the seconds that can be held in a {@code long}. This is greater than the current
+ * constraints similar to {@link Instant} . The duration uses nanosecond resolution with a maximum
+ * value of the seconds that can be held in a {@code long} . This is greater than the current
  * estimated age of the universe.
  *
- * The range of a duration requires the storage of a number larger than a {@code long}. To achieve
+ * The range of a duration requires the storage of a number larger than a {@code long} . To achieve
  * this, the class stores a {@code long} representing seconds and an {@code int} representing
  * nanosecond-of-second, which will always be between 0 and 999,999,999.
  *
@@ -539,7 +539,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    *
    * The length of the duration is stored using two fields - seconds and nanoseconds. The
    * nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to the length in
-   * seconds. The total duration is defined by calling this method and {@link #getNano()}.
+   * seconds. The total duration is defined by calling this method and {@link #getNano()} .
    *
    * A {@code Duration} represents a directed distance between two points on the time-line. A
    * negative duration is expressed by the negative sign of the seconds part. A duration of -1
@@ -555,7 +555,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    *
    * The length of the duration is stored using two fields - seconds and nanoseconds. The
    * nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to the length in
-   * seconds. The total duration is defined by calling this method and {@link #getSeconds()}.
+   * seconds. The total duration is defined by calling this method and {@link #getSeconds()} .
    *
    * A {@code Duration} represents a directed distance between two points on the time-line. A
    * negative duration is expressed by the negative sign of the seconds part. A duration of -1
@@ -577,7 +577,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param seconds
    *   the seconds to represent, may be negative
    * @return
-   *   a { @code Duration} based on this period with the requested seconds, not null
+   *   a {@code Duration} based on this period with the requested seconds, not null
    */
   def withSeconds(seconds: Long): Duration = Duration.create(seconds, nanos)
 
@@ -592,7 +592,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanoOfSecond
    *   the nano-of-second to represent, from 0 to 999,999,999
    * @return
-   *   a { @code Duration} based on this period with the requested nano-of-second, not null
+   *   a {@code Duration} based on this period with the requested nano-of-second, not null
    * @throws DateTimeException
    *   if the nano-of-second is invalid
    */
@@ -609,7 +609,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param duration
    *   the duration to add, positive or negative, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration added, not null
+   *   a {@code Duration} based on this duration with the specified duration added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -630,7 +630,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param unit
    *   the unit that the period is measured in, must have an exact duration, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration added, not null
+   *   a {@code Duration} based on this duration with the specified duration added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -667,7 +667,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param daysToAdd
    *   the days to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified days added, not null
+   *   a {@code Duration} based on this duration with the specified days added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -682,7 +682,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param hoursToAdd
    *   the hours to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified hours added, not null
+   *   a {@code Duration} based on this duration with the specified hours added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -697,7 +697,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param minutesToAdd
    *   the minutes to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified minutes added, not null
+   *   a {@code Duration} based on this duration with the specified minutes added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -712,7 +712,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param secondsToAdd
    *   the seconds to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified seconds added, not null
+   *   a {@code Duration} based on this duration with the specified seconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -726,7 +726,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param millisToAdd
    *   the milliseconds to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified milliseconds added, not null
+   *   a {@code Duration} based on this duration with the specified milliseconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -741,7 +741,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanoseconds to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified nanoseconds added, not null
+   *   a {@code Duration} based on this duration with the specified nanoseconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -757,7 +757,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanos to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified seconds added, not null
+   *   a {@code Duration} based on this duration with the specified seconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -780,7 +780,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param duration
    *   the duration to subtract, positive or negative, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration subtracted, not null
+   *   a {@code Duration} based on this duration with the specified duration subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -806,7 +806,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param unit
    *   the unit that the period is measured in, must have an exact duration, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration subtracted, not null
+   *   a {@code Duration} based on this duration with the specified duration subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -822,7 +822,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param daysToSubtract
    *   the days to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified days subtracted, not null
+   *   a {@code Duration} based on this duration with the specified days subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -838,7 +838,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param hoursToSubtract
    *   the hours to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified hours subtracted, not null
+   *   a {@code Duration} based on this duration with the specified hours subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -854,7 +854,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param minutesToSubtract
    *   the minutes to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified minutes subtracted, not null
+   *   a {@code Duration} based on this duration with the specified minutes subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -870,7 +870,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param secondsToSubtract
    *   the seconds to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified seconds subtracted, not null
+   *   a {@code Duration} based on this duration with the specified seconds subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -886,7 +886,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param millisToSubtract
    *   the milliseconds to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified milliseconds subtracted, not
+   *   a {@code Duration} based on this duration with the specified milliseconds subtracted, not
    *   null
    * @throws ArithmeticException
    *   if numeric overflow occurs
@@ -903,8 +903,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanosToSubtract
    *   the nanoseconds to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified nanoseconds subtracted, not
-   *   null
+   *   a {@code Duration} based on this duration with the specified nanoseconds subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -920,7 +919,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param multiplicand
    *   the value to multiply the duration by, positive or negative
    * @return
-   *   a { @code Duration} based on this duration multiplied by the specified scalar, not null
+   *   a {@code Duration} based on this duration multiplied by the specified scalar, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -937,7 +936,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param divisor
    *   the value to divide the duration by, positive or negative, not zero
    * @return
-   *   a { @code Duration} based on this duration divided by the specified divisor, not null
+   *   a {@code Duration} based on this duration divided by the specified divisor, not null
    * @throws ArithmeticException
    *   if the divisor is zero
    * @throws ArithmeticException
@@ -950,7 +949,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
 
   /**
    * Converts this duration to the total length in seconds and fractional nanoseconds expressed as a
-   * {@code BigDecimal}.
+   * {@code BigDecimal} .
    *
    * @return
    *   the total length of the duration in seconds, with a scale of 9, not null
@@ -990,12 +989,12 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * Returns a copy of this duration with the length negated.
    *
    * This method swaps the sign of the total length of this duration. For example, {@code PT1.3S}
-   * will be returned as {@code PT-1.3S}.
+   * will be returned as {@code PT-1.3S} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code Duration} based on this duration with the amount negated, not null
+   *   a {@code Duration} based on this duration with the amount negated, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -1005,12 +1004,12 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * Returns a copy of this duration with a positive length.
    *
    * This method returns a positive duration by effectively removing the sign from any negative
-   * total length. For example, {@code PT-1.3S} will be returned as {@code PT1.3S}.
+   * total length. For example, {@code PT-1.3S} will be returned as {@code PT1.3S} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code Duration} based on this duration with an absolute length, not null
+   *   a {@code Duration} based on this duration with an absolute length, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -1200,7 +1199,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   def toMillisPart: Int = (nanos / Duration.NANOS_PER_MILLI).toInt
 
   /**
-   * Converts this duration to the total length in nanoseconds expressed as a {@code long}.
+   * Converts this duration to the total length in nanoseconds expressed as a {@code long} .
    *
    * If this duration is too large to fit in a {@code long} nanoseconds, then an exception is
    * thrown.
@@ -1231,10 +1230,10 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   def toNanosPart: Int = nanos
 
   /**
-   * Compares this duration to the specified {@code Duration}.
+   * Compares this duration to the specified {@code Duration} .
    *
    * The comparison is based on the total length of the durations. It is "consistent with equals",
-   * as defined by {@link Comparable}.
+   * as defined by {@link Comparable} .
    *
    * @param otherDuration
    *   the other duration to compare to, not null
@@ -1250,7 +1249,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   override def compareTo(other: Duration): Int = compare(other)
 
   /**
-   * Checks if this duration is equal to the specified {@code Duration}.
+   * Checks if this duration is equal to the specified {@code Duration} .
    *
    * The comparison is based on the total length of the durations.
    *
@@ -1276,16 +1275,16 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
 
   /**
    * A string representation of this duration using ISO-8601 seconds based representation, such as
-   * {@code PT8H6M12.345S}.
+   * {@code PT8H6M12.345S} .
    *
-   * The format of the returned string will be {@code PTnHnMnS}, where n is the relevant hours,
+   * The format of the returned string will be {@code PTnHnMnS} , where n is the relevant hours,
    * minutes or seconds part of the duration. Any fractional seconds are placed after a decimal
    * point i the seconds section. If a section has a zero value, it is omitted. The hours, minutes
    * and seconds will all have the same sign.
    *
    * Examples: <pre> "20.345 seconds" -> "PT20.345S "15 minutes" (15 * 60 seconds) -> "PT15M" "10
    * hours" (10 * 3600 seconds) -> "PT10H" "2 days" (2 * 86400 seconds) -> "PT48H" </pre> Note that
-   * multiples of 24 hours are not output as days to avoid confusion with {@code Period}.
+   * multiples of 24 hours are not output as days to avoid confusion with {@code Period} .
    *
    * @return
    *   an ISO-8601 representation of this duration, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/Instant.scala b/core/shared/src/main/scala/org/threeten/bp/Instant.scala
index 800b33d9e..4ea44fb92 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Instant.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Instant.scala
@@ -79,10 +79,10 @@ object Instant {
   private def MILLIS_PER_SEC = 1000
 
   /**
-   * The minimum supported {@code Instant}, '-1000000000-01-01T00:00Z'. This could be used by an
+   * The minimum supported {@code Instant} , '-1000000000-01-01T00:00Z'. This could be used by an
    * application as a "far past" instant.
    *
-   * This is one year earlier than the minimum {@code LocalDateTime}. This provides sufficient
+   * This is one year earlier than the minimum {@code LocalDateTime} . This provides sufficient
    * values to handle the range of {@code ZoneOffset} which affect the instant in addition to the
    * local date-time. The value is also chosen such that the value of the year fits in an {@code
    * int}.
@@ -90,12 +90,12 @@ object Instant {
   lazy val MIN: Instant = Instant.ofEpochSecond(MIN_SECOND, 0)
 
   /**
-   * The maximum supported {@code Instant}, '1000000000-12-31T23:59:59.999999999Z'. This could be
+   * The maximum supported {@code Instant} , '1000000000-12-31T23:59:59.999999999Z'. This could be
    * used by an application as a "far future" instant.
    *
-   * This is one year later than the maximum {@code LocalDateTime}. This provides sufficient values
+   * This is one year later than the maximum {@code LocalDateTime} . This provides sufficient values
    * to handle the range of {@code ZoneOffset} which affect the instant in addition to the local
-   * date-time. The value is also chosen such that the value of the year fits in an {@code int}.
+   * date-time. The value is also chosen such that the value of the year fits in an {@code int} .
    */
   lazy val MAX: Instant = Instant.ofEpochSecond(MAX_SECOND, 999999999)
 
@@ -118,7 +118,7 @@ object Instant {
    * This will query the specified clock to obtain the current time.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -195,20 +195,20 @@ object Instant {
    * Obtains an instance of {@code Instant} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Instant}.
+   * converts the arbitrary temporal object to an instance of {@code Instant} .
    *
    * The conversion extracts the {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS} and {@link
    * ChronoField#NANO_OF_SECOND NANO_OF_SECOND} fields.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code Instant::from}.
+   * to be used as a query via method reference, {@code Instant::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the instant, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code Instant}
+   *   if unable to convert to an {@code Instant}
    */
   def from(temporal: TemporalAccessor): Instant =
     try {
@@ -272,10 +272,10 @@ object Instant {
  * event time-stamps in the application.
  *
  * For practicality, the instant is stored with some constraints. The measurable time-line is
- * restricted to the number of seconds that can be held in a {@code long}. This is greater than the
+ * restricted to the number of seconds that can be held in a {@code long} . This is greater than the
  * current estimated age of the universe. The instant is stored to nanosecond resolution.
  *
- * The range of an instant requires the storage of a number larger than a {@code long}. To achieve
+ * The range of an instant requires the storage of a number larger than a {@code long} . To achieve
  * this, the class stores a {@code long} representing epoch-seconds and an {@code int} representing
  * nanosecond-of-second, which will always be between 0 and 999,999,999. The epoch-seconds are
  * measured from the standard Java epoch of {@code 1970-01-01T00:00:00Z} where instants after the
@@ -335,12 +335,12 @@ object Instant {
  * 1/1000th longer or shorter than a real SI second.
  *
  * One final problem is the definition of the agreed international civil time before the
- * introduction of modern UTC in 1972. This includes the Java epoch of {@code 1970-01-01}. It is
+ * introduction of modern UTC in 1972. This includes the Java epoch of {@code 1970-01-01} . It is
  * intended that instants before 1972 be interpreted based on the solar day divided into 86400
  * subdivisions.
  *
- * The Java time-scale is used by all date-time classes. This includes {@code Instant}, {@code
- * LocalDate}, {@code LocalTime}, {@code OffsetDateTime}, {@code ZonedDateTime} and {@code
+ * The Java time-scale is used by all date-time classes. This includes {@code Instant} , {@code
+ * LocalDate}, {@code LocalTime} , {@code OffsetDateTime} , {@code ZonedDateTime} and {@code
  * Duration}.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
@@ -372,7 +372,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code MICRO_OF_SECOND} <li>{@code MILLI_OF_SECOND}
    * <li>{@code INSTANT_SECONDS} </ul> All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -399,9 +399,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -415,7 +415,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   override def range(field: TemporalField): ValueRange = super.range(field)
 
   /**
-   * Gets the value of the specified field from this instant as an {@code int}.
+   * Gets the value of the specified field from this instant as an {@code int} .
    *
    * This queries this instant for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
@@ -427,7 +427,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * DateTimeException}. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -453,7 +453,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
     }
 
   /**
-   * Gets the value of the specified field from this instant as a {@code long}.
+   * Gets the value of the specified field from this instant as a {@code long} .
    *
    * This queries this instant for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -461,9 +461,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -493,7 +493,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Gets the number of seconds from the Java epoch of 1970-01-01T00:00:00Z.
    *
    * The epoch second count is a simple incrementing count of seconds where second 0 is
-   * 1970-01-01T00:00:00Z. The nanosecond part of the day is returned by {@code getNanosOfSecond}.
+   * 1970-01-01T00:00:00Z. The nanosecond part of the day is returned by {@code getNanosOfSecond} .
    *
    * @return
    *   the seconds from the epoch of 1970-01-01T00:00:00Z
@@ -504,7 +504,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Gets the number of nanoseconds, later along the time-line, from the start of the second.
    *
    * The nanosecond-of-second value measures the total number of nanoseconds from the second
-   * returned by {@code getEpochSecond}.
+   * returned by {@code getEpochSecond} .
    *
    * @return
    *   the nanoseconds within the second, always positive, never exceeds 999,999,999
@@ -514,7 +514,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * Returns an adjusted copy of this instant.
    *
-   * This returns a new {@code Instant}, based on this one, with the date adjusted. The adjustment
+   * This returns a new {@code Instant} , based on this one, with the date adjusted. The adjustment
    * takes place using the specified adjuster strategy object. Read the documentation of the
    * adjuster to understand what adjustment will be made.
    *
@@ -527,7 +527,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   an { @code Instant} based on { @code this} with the adjustment made, not null
+   *   an {@code Instant} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -539,7 +539,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * Returns a copy of this instant with the specified field set to a new value.
    *
-   * This returns a new {@code Instant}, based on this one, with the value for the specified field
+   * This returns a new {@code Instant} , based on this one, with the value for the specified field
    * changed. If it is not possible to set the value, because the field is not supported or for some
    * other reason, an exception is thrown.
    *
@@ -555,9 +555,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -568,7 +568,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   an { @code Instant} based on { @code this} with the specified field set, not null
+   *   an {@code Instant} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -602,19 +602,19 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    *
    * Truncating the instant returns a copy of the original with fields smaller than the specified
    * unit set to zero. The fields are calculated on the basis of using a UTC offset as seen in
-   * {@code toString}. For example, truncating with the {@link ChronoUnit#MINUTES MINUTES} unit will
-   * round down to the nearest minute, setting the seconds and nanoseconds to zero.
+   * {@code toString} . For example, truncating with the {@link ChronoUnit#MINUTES MINUTES} unit
+   * will round down to the nearest minute, setting the seconds and nanoseconds to zero.
    *
    * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   an { @code Instant} based on this instant with the time truncated, not null
+   *   an {@code Instant} based on this instant with the time truncated, not null
    * @throws DateTimeException
    *   if the unit is invalid for truncation
    */
@@ -636,18 +636,18 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * {@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   override def plus(amount: TemporalAmount): Instant = amount.addTo(this).asInstanceOf[Instant]
 
   /**
    * {@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   def plus(amountToAdd: Long, unit: TemporalUnit): Instant = {
     unit match {
@@ -686,7 +686,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param secondsToAdd
    *   the seconds to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified seconds added, not null
+   *   an {@code Instant} based on this instant with the specified seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -702,7 +702,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param millisToAdd
    *   the milliseconds to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified milliseconds added, not null
+   *   an {@code Instant} based on this instant with the specified milliseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -719,7 +719,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanoseconds to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified nanoseconds added, not null
+   *   an {@code Instant} based on this instant with the specified nanoseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -737,7 +737,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanos to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified seconds added, not null
+   *   an {@code Instant} based on this instant with the specified seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -757,9 +757,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * {@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   override def minus(amount: TemporalAmount): Instant =
     amount.subtractFrom(this).asInstanceOf[Instant]
@@ -767,9 +767,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * {@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): Instant =
     if (amountToSubtract == Long.MinValue) plus(Long.MaxValue, unit).plus(1, unit)
@@ -783,7 +783,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param secondsToSubtract
    *   the seconds to subtract, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified seconds subtracted, not null
+   *   an {@code Instant} based on this instant with the specified seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -803,8 +803,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param millisToSubtract
    *   the milliseconds to subtract, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified milliseconds subtracted, not
-   *   null
+   *   an {@code Instant} based on this instant with the specified milliseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -824,7 +823,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param nanosToSubtract
    *   the nanoseconds to subtract, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified nanoseconds subtracted, not null
+   *   an {@code Instant} based on this instant with the specified nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -903,28 +902,28 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * points are {@code this} and the specified instant. The result will be negative if the end is
    * before the start. The calculation returns a whole number, representing the number of complete
    * units between the two instants. The {@code Temporal} passed to this method is converted to a
-   * {@code Instant} using {@link #from(TemporalAccessor)}. For example, the period in days between
-   * two dates can be calculated using {@code startInstant.until(endInstant, SECONDS)}.
+   * {@code Instant} using {@link #from(TemporalAccessor)} . For example, the period in days between
+   * two dates can be calculated using {@code startInstant.until(endInstant, SECONDS)} .
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, SECONDS); // this method dateTime.plus(SECONDS.between(start, end));
    * // use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS}, {@code
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code NANOS}
+   * , {@code MICROS} , {@code MILLIS} , {@code SECONDS} , {@code MINUTES} , {@code HOURS} , {@code
    * HALF_DAYS} and {@code DAYS} are supported. Other {@code ChronoUnit} values will throw an
    * exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date, which is converted to an { @code Instant}, not null
+   *   the end date, which is converted to an {@code Instant} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -981,7 +980,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   }
 
   /**
-   * Combines this instant with an offset to create an {@code OffsetDateTime}.
+   * Combines this instant with an offset to create an {@code OffsetDateTime} .
    *
    * This returns an {@code OffsetDateTime} formed from this instant at the specified offset from
    * UTC/Greenwich. An exception will be thrown if the instant is too large to fit into an offset
@@ -1000,7 +999,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   def atOffset(offset: ZoneOffset): OffsetDateTime = OffsetDateTime.ofInstant(this, offset)
 
   /**
-   * Combines this instant with a time-zone to create a {@code ZonedDateTime}.
+   * Combines this instant with a time-zone to create a {@code ZonedDateTime} .
    *
    * This returns an {@code ZonedDateTime} formed from this instant at the specified time-zone. An
    * exception will be thrown if the instant is too large to fit into a zoned date-time.
@@ -1054,7 +1053,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Compares this instant to the specified instant.
    *
    * The comparison is based on the time-line position of the instants. It is "consistent with
-   * equals", as defined by {@link Comparable}.
+   * equals", as defined by {@link Comparable} .
    *
    * @param otherInstant
    *   the other instant to compare to, not null
@@ -1127,7 +1126,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * A string representation of this instant using ISO-8601 representation.
    *
-   * The format used is the same as {@link DateTimeFormatter#ISO_INSTANT}.
+   * The format used is the same as {@link DateTimeFormatter#ISO_INSTANT} .
    *
    * @return
    *   an ISO-8601 representation of this instant, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala b/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala
index c27f26473..06a0a2aa5 100644
--- a/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala
@@ -69,13 +69,13 @@ import org.threeten.bp.zone.ZoneRules
 object LocalDate {
 
   /**
-   * The minimum supported {@code LocalDate}, '-999999999-01-01'. This could be used by an
+   * The minimum supported {@code LocalDate} , '-999999999-01-01'. This could be used by an
    * application as a "far past" date.
    */
   lazy val MIN: LocalDate = LocalDate.of(Year.MIN_VALUE, 1, 1)
 
   /**
-   * The maximum supported {@code LocalDate}, '+999999999-12-31'. This could be used by an
+   * The maximum supported {@code LocalDate} , '+999999999-12-31'. This could be used by an
    * application as a "far future" date.
    */
   lazy val MAX: LocalDate = LocalDate.of(Year.MAX_VALUE, 12, 31)
@@ -124,7 +124,7 @@ object LocalDate {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@link Clock dependency injection}.
+   * {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -263,20 +263,20 @@ object LocalDate {
    * Obtains an instance of {@code LocalDate} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code LocalDate}.
+   * converts the arbitrary temporal object to an instance of {@code LocalDate} .
    *
    * The conversion uses the {@link TemporalQueries#localDate()} query, which relies on extracting
    * the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code LocalDate::from}.
+   * to be used as a query via method reference, {@code LocalDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the local date, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code LocalDate}
+   *   if unable to convert to a {@code LocalDate}
    */
   def from(temporal: TemporalAccessor): LocalDate = {
     val date: LocalDate = temporal.query(TemporalQueries.localDate)
@@ -288,7 +288,7 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from a text string such as {@code 2007-12-03}.
+   * Obtains an instance of {@code LocalDate} from a text string such as {@code 2007-12-03} .
    *
    * The string must represent a valid date and is parsed using {@link
    * org.threeten.bp.format.DateTimeFormatter#ISO_LOCAL_DATE}.
@@ -376,11 +376,11 @@ object LocalDate {
 }
 
 /**
- * A date without a time-zone in the ISO-8601 calendar system, such as {@code 2007-12-03}.
+ * A date without a time-zone in the ISO-8601 calendar system, such as {@code 2007-12-03} .
  *
  * {@code LocalDate} is an immutable date-time object that represents a date, often viewed as
  * year-month-day. Other date fields, such as day-of-year, day-of-week and week-of-year, can also be
- * accessed. For example, the value "2nd October 2007" can be stored in a {@code LocalDate}.
+ * accessed. For example, the value "2nd October 2007" can be stored in a {@code LocalDate} .
  *
  * This class does not store or represent a time or time-zone. Instead, it is a description of the
  * date, as used for birthdays. It cannot represent an instant on the time-line without additional
@@ -431,7 +431,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * <li>{@code MONTH_OF_YEAR} <li>{@code EPOCH_MONTH} <li>{@code YEAR_OF_ERA} <li>{@code YEAR}
    * <li>{@code ERA} </ul> All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -451,9 +451,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -484,7 +484,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this date as an {@code int}.
+   * Gets the value of the specified field from this date as an {@code int} .
    *
    * This queries this date for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
@@ -493,10 +493,10 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date,
    * except {@code EPOCH_DAY} and {@code EPOCH_MONTH} which are too large to fit in an {@code int}
-   * and throw a {@code DateTimeException}. All other {@code ChronoField} instances will throw a
-   * {@code DateTimeException}.
+   * and throw a {@code DateTimeException} . All other {@code ChronoField} instances will throw a
+   * {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -514,16 +514,16 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     else super.get(field)
 
   /**
-   * Gets the value of the specified field from this date as a {@code long}.
+   * Gets the value of the specified field from this date as a {@code long} .
    *
    * This queries this date for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -594,7 +594,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * IsoChronology} using the {@code ==} operator.
    *
    * @return
-   *   the { @code IsoChronology} era constant applicable at this date, not null
+   *   the {@code IsoChronology} era constant applicable at this date, not null
    */
   override def getEra: Era = super.getEra
 
@@ -603,8 +603,8 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This method returns the primitive {@code int} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@code get(YEAR)} . To obtain the
+   * year-of-era, use {@code get(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -615,7 +615,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Gets the month-of-year field from 1 to 12.
    *
    * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * clearer if the enum {@link Month} is used by calling {@link #getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -629,7 +629,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This method returns the enum {@link Month} for the month. This avoids confusion as to what
    * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * provides the {@link Month#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -659,13 +659,13 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   def getDayOfYear: Int = getMonth.firstDayOfYear(isLeapYear) + day - 1
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@code DayOfWeek} .
    *
    * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
    * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * enum provides the {@link DayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@code DayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -722,15 +722,15 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Returns an adjusted copy of this date.
    *
-   * This returns a new {@code LocalDate}, based on this one, with the date adjusted. The adjustment
-   * takes place using the specified adjuster strategy object. Read the documentation of the
-   * adjuster to understand what adjustment will be made.
+   * This returns a new {@code LocalDate} , based on this one, with the date adjusted. The
+   * adjustment takes place using the specified adjuster strategy object. Read the documentation of
+   * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@link TemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay}. The adjuster is
+   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay} . The adjuster is
    * responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -747,7 +747,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code LocalDate} based on { @code this} with the adjustment made, not null
+   *   a {@code LocalDate} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -760,8 +760,8 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Returns a copy of this date with the specified field set to a new value.
    *
-   * This returns a new {@code LocalDate}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the year, month or
+   * This returns a new {@code LocalDate} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
    *
@@ -787,7 +787,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * {@code LocalDate} with the specified day-of-year. The year will be unchanged. If the
    * day-of-year is invalid for the year, then a {@code DateTimeException} is thrown. <li>{@code
    * EPOCH_DAY} - Returns a {@code LocalDate} with the specified epoch-day. This completely replaces
-   * the date and is equivalent to {@link #ofEpochDay(long)}. <li>{@code ALIGNED_WEEK_OF_MONTH} -
+   * the date and is equivalent to {@link #ofEpochDay(long)} . <li>{@code ALIGNED_WEEK_OF_MONTH} -
    * Returns a {@code LocalDate} with the specified aligned-week-of-month. Aligned weeks are counted
    * such that the first week of a given month starts on the first day of that month. This
    * adjustment moves the date in whole week chunks to match the specified week. The result will
@@ -817,9 +817,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -830,7 +830,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code LocalDate} based on { @code this} with the specified field set, not null
+   *   a {@code LocalDate} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -870,7 +870,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code LocalDate} based on this date with the requested year, not null
+   *   a {@code LocalDate} based on this date with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -891,7 +891,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   a { @code LocalDate} based on this date with the requested month, not null
+   *   a {@code LocalDate} based on this date with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -912,7 +912,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   a { @code LocalDate} based on this date with the requested day, not null
+   *   a {@code LocalDate} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -931,7 +931,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   a { @code LocalDate} based on this date with the requested day, not null
+   *   a {@code LocalDate} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -947,14 +947,14 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * This method returns a new date based on this date with the specified period added. The amount
    * is typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}.
+   * to {@link #plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code LocalDate} based on this date with the addition made, not null
+   *   a {@code LocalDate} based on this date with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -977,7 +977,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code LocalDate} based on this date with the specified period added, not null
+   *   a {@code LocalDate} based on this date with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1015,7 +1015,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param yearsToAdd
    *   the years to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the years added, not null
+   *   a {@code LocalDate} based on this date with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1042,7 +1042,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param monthsToAdd
    *   the months to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the months added, not null
+   *   a {@code LocalDate} based on this date with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1071,7 +1071,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param weeksToAdd
    *   the weeks to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the weeks added, not null
+   *   a {@code LocalDate} based on this date with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1091,7 +1091,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param daysToAdd
    *   the days to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the days added, not null
+   *   a {@code LocalDate} based on this date with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1109,14 +1109,14 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * This method returns a new date based on this date with the specified period subtracted. The
    * amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@link #minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code LocalDate} based on this date with the subtraction made, not null
+   *   a {@code LocalDate} based on this date with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1140,7 +1140,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code LocalDate} based on this date with the specified period subtracted, not null
+   *   a {@code LocalDate} based on this date with the specified period subtracted, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1164,7 +1164,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param yearsToSubtract
    *   the years to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the years subtracted, not null
+   *   a {@code LocalDate} based on this date with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1187,7 +1187,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param monthsToSubtract
    *   the months to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the months subtracted, not null
+   *   a {@code LocalDate} based on this date with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1209,7 +1209,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param weeksToSubtract
    *   the weeks to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the weeks subtracted, not null
+   *   a {@code LocalDate} based on this date with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1231,7 +1231,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param daysToSubtract
    *   the days to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the days subtracted, not null
+   *   a {@code LocalDate} based on this date with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1297,7 +1297,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This calculates the period between two dates in terms of a single unit. The start and end
    * points are {@code this} and the specified date. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code LocalDate}. For
+   * before the start. The {@code Temporal} passed to this method must be a {@code LocalDate} . For
    * example, the period in days between two dates can be calculated using {@code
    * startDate.until(endDate, DAYS)}.
    *
@@ -1305,25 +1305,25 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * two dates. For example, the period in months between 2012-06-15 and 2012-08-14 will only be one
    * month as it is one day short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code DAYS},
-   * {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code CENTURIES}, {@code
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code DAYS} ,
+   * {@code WEEKS} , {@code MONTHS} , {@code YEARS} , {@code DECADES} , {@code CENTURIES} , {@code
    * MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values will throw an
    * exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date, which is converted to a { @code LocalDate}, not null
+   *   the end date, which is converted to a {@code LocalDate} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1362,7 +1362,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Calculates the period between this date and another date as a {@code Period}.
+   * Calculates the period between this date and another date as a {@code Period} .
    *
    * This calculates the period between two dates in terms of years, months and days. The start and
    * end points are {@code this} and the specified date. The result will be negative if the end is
@@ -1382,7 +1382,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * sign will be the same in each of year, month and day.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method. The
-   * second is to use {@link Period#between(LocalDate, LocalDate)}: <pre> // these two lines are
+   * second is to use {@link Period#between(LocalDate, LocalDate)} : <pre> // these two lines are
    * equivalent period = start.until(end); period = Period.between(start, end); </pre> The choice
    * should be made based on which makes the code more readable.
    *
@@ -1409,7 +1409,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@code LocalDateTime} .
    *
    * This returns a {@code LocalDateTime} formed from this date at the specified time. All possible
    * combinations of date and time are valid.
@@ -1422,7 +1422,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   override def atTime(time: LocalTime): LocalDateTime = LocalDateTime.of(this, time)
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@code LocalDateTime} .
    *
    * This returns a {@code LocalDateTime} formed from this date at the specified hour and minute.
    * The seconds and nanosecond fields will be set to zero. The individual time fields must be
@@ -1440,7 +1440,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   def atTime(hour: Int, minute: Int): LocalDateTime = atTime(LocalTime.of(hour, minute))
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@code LocalDateTime} .
    *
    * This returns a {@code LocalDateTime} formed from this date at the specified hour, minute and
    * second. The nanosecond field will be set to zero. The individual time fields must be within
@@ -1461,7 +1461,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     atTime(LocalTime.of(hour, minute, second))
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@code LocalDateTime} .
    *
    * This returns a {@code LocalDateTime} formed from this date at the specified hour, minute,
    * second and nanosecond. The individual time fields must be within their valid range. All
@@ -1484,7 +1484,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     atTime(LocalTime.of(hour, minute, second, nanoOfSecond))
 
   /**
-   * Combines this date with an offset time to create an {@code OffsetDateTime}.
+   * Combines this date with an offset time to create an {@code OffsetDateTime} .
    *
    * This returns an {@code OffsetDateTime} formed from this date at the specified time. All
    * possible combinations of date and time are valid.
@@ -1523,10 +1523,10 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * of midnight on the date. In the case of a gap, the zoned date-time will represent the instant
    * just after the gap.
    *
-   * If the zone ID is a {@link ZoneOffset}, then the result always has a time of midnight.
+   * If the zone ID is a {@link ZoneOffset} , then the result always has a time of midnight.
    *
    * To convert to a specific time in a given time-zone call {@link #atTime(LocalTime)} followed by
-   * {@link LocalDateTime#atZone(ZoneId)}.
+   * {@link LocalDateTime#atZone(ZoneId)} .
    *
    * @param zone
    *   the zone ID to use, not null
@@ -1568,11 +1568,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Compares this date to another date.
    *
    * The comparison is primarily based on the date, from earliest to latest. It is "consistent with
-   * equals", as defined by {@link Comparable}.
+   * equals", as defined by {@link Comparable} .
    *
-   * If all the dates being compared are instances of {@code LocalDate}, then the comparison will be
-   * entirely based on the date. If some dates being compared are in different chronologies, then
-   * the chronology is also considered, see {@link ChronoLocalDate#compareTo}.
+   * If all the dates being compared are instances of {@code LocalDate} , then the comparison will
+   * be entirely based on the date. If some dates being compared are in different chronologies, then
+   * the chronology is also considered, see {@link ChronoLocalDate#compareTo} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1598,12 +1598,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This checks to see if this date represents a point on the local time-line after the other date.
    * <pre> LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1);
-   * a.isAfter(b) == false
-   * a.isAfter(a) == false b.isAfter(a) == true </pre>
+   * a.isAfter(b) == false a.isAfter(a) == false b.isAfter(a) == true </pre>
    *
    * This method only considers the position of the two dates on the local time-line. It does not
    * take into account the chronology, or calendar system. This is different from the comparison in
-   * {@link #compareTo(ChronoLocalDate)}, but is the same approach as {@link #DATE_COMPARATOR}.
+   * {@link #compareTo(ChronoLocalDate)} , but is the same approach as {@link #DATE_COMPARATOR} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1619,12 +1618,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This checks to see if this date represents a point on the local time-line before the other
    * date. <pre> LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1);
-   * a.isBefore(b) == true
-   * a.isBefore(a) == false b.isBefore(a) == false </pre>
+   * a.isBefore(b) == true a.isBefore(a) == false b.isBefore(a) == false </pre>
    *
    * This method only considers the position of the two dates on the local time-line. It does not
    * take into account the chronology, or calendar system. This is different from the comparison in
-   * {@link #compareTo(ChronoLocalDate)}, but is the same approach as {@link #DATE_COMPARATOR}.
+   * {@link #compareTo(ChronoLocalDate)} , but is the same approach as {@link #DATE_COMPARATOR} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1640,12 +1638,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This checks to see if this date represents the same point on the local time-line as the other
    * date. <pre> LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1);
-   * a.isEqual(b) == false
-   * a.isEqual(a) == true b.isEqual(a) == false </pre>
+   * a.isEqual(b) == false a.isEqual(a) == true b.isEqual(a) == false </pre>
    *
    * This method only considers the position of the two dates on the local time-line. It does not
    * take into account the chronology, or calendar system. This is different from the comparison in
-   * {@link #compareTo(ChronoLocalDate)} but is the same approach as {@link #DATE_COMPARATOR}.
+   * {@link #compareTo(ChronoLocalDate)} but is the same approach as {@link #DATE_COMPARATOR} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1690,9 +1687,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Outputs this date as a {@code String}, such as {@code 2007-12-03}.
+   * Outputs this date as a {@code String} , such as {@code 2007-12-03} .
    *
-   * The output will be in the ISO-8601 format {@code yyyy-MM-dd}.
+   * The output will be in the ISO-8601 format {@code yyyy-MM-dd} .
    *
    * @return
    *   a string representation of this date, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala
index 8dfff04e3..b8d932052 100644
--- a/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala
@@ -63,16 +63,16 @@ import org.threeten.bp.zone.ZoneRules
 object LocalDateTime {
 
   /**
-   * The minimum supported {@code LocalDateTime}, '-999999999-01-01T00:00:00'. This is the local
+   * The minimum supported {@code LocalDateTime} , '-999999999-01-01T00:00:00'. This is the local
    * date-time of midnight at the start of the minimum date. This combines {@link LocalDate#MIN} and
-   * {@link LocalTime#MIN}. This could be used by an application as a "far past" date-time.
+   * {@link LocalTime#MIN} . This could be used by an application as a "far past" date-time.
    */
   lazy val MIN: LocalDateTime = LocalDateTime.of(LocalDate.MIN, LocalTime.MIN)
 
   /**
-   * The maximum supported {@code LocalDateTime}, '+999999999-12-31T23:59:59.999999999'. This is the
-   * local date-time just before midnight at the end of the maximum date. This combines {@link
-   * LocalDate#MAX} and {@link LocalTime#MAX}. This could be used by an application as a "far
+   * The maximum supported {@code LocalDateTime} , '+999999999-12-31T23:59:59.999999999'. This is
+   * the local date-time just before midnight at the end of the maximum date. This combines {@link
+   * LocalDate#MAX} and {@link LocalTime#MAX} . This could be used by an application as a "far
    * future" date-time.
    */
   lazy val MAX: LocalDateTime = LocalDateTime.of(LocalDate.MAX, LocalTime.MAX)
@@ -420,19 +420,19 @@ object LocalDateTime {
    * Obtains an instance of {@code LocalDateTime} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code LocalDateTime}.
+   * converts the arbitrary temporal object to an instance of {@code LocalDateTime} .
    *
-   * The conversion extracts and combines {@code LocalDate} and {@code LocalTime}.
+   * The conversion extracts and combines {@code LocalDate} and {@code LocalTime} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code LocalDateTime::from}.
+   * to be used as a query via method reference, {@code LocalDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the local date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code LocalDateTime}
+   *   if unable to convert to a {@code LocalDateTime}
    */
   def from(temporal: TemporalAccessor): LocalDateTime =
     temporal match {
@@ -563,7 +563,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * <li>{@code YEAR} <li>{@code ERA} </ul> All other {@code ChronoField} instances will return
    * false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -594,9 +594,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -617,7 +617,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     }
 
   /**
-   * Gets the value of the specified field from this date-time as an {@code int}.
+   * Gets the value of the specified field from this date-time as an {@code int} .
    *
    * This queries this date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -625,11 +625,11 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY}, {@code EPOCH_DAY} and {@code EPOCH_MONTH}
-   * which are too large to fit in an {@code int} and throw a {@code DateTimeException}. All other
-   * {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * except {@code NANO_OF_DAY} , {@code MICRO_OF_DAY} , {@code EPOCH_DAY} and {@code EPOCH_MONTH}
+   * which are too large to fit in an {@code int} and throw a {@code DateTimeException} . All other
+   * {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -652,7 +652,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     }
 
   /**
-   * Gets the value of the specified field from this date-time as a {@code long}.
+   * Gets the value of the specified field from this date-time as a {@code long} .
    *
    * This queries this date-time for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -660,9 +660,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -689,8 +689,8 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This method returns the primitive {@code int} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@code get(YEAR)} . To obtain the
+   * year-of-era, use {@code get(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -701,7 +701,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * Gets the month-of-year field from 1 to 12.
    *
    * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * clearer if the enum {@link Month} is used by calling {@link #getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -715,7 +715,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This method returns the enum {@link Month} for the month. This avoids confusion as to what
    * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * provides the {@link Month#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -745,13 +745,13 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def getDayOfYear: Int = date.getDayOfYear
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@code DayOfWeek} .
    *
    * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
    * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * enum provides the {@link DayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@code DayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -794,15 +794,15 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Returns an adjusted copy of this date-time.
    *
-   * This returns a new {@code LocalDateTime}, based on this one, with the date-time adjusted. The
+   * This returns a new {@code LocalDateTime} , based on this one, with the date-time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@link TemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay MonthDay}. The adjuster
+   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay MonthDay} . The adjuster
    * is responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -810,7 +810,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * result = localDateTime.with(JULY).with(lastDayOfMonth()); </pre>
    *
-   * The classes {@link LocalDate} and {@link LocalTime} implement {@code TemporalAdjuster}, thus
+   * The classes {@link LocalDate} and {@link LocalTime} implement {@code TemporalAdjuster} , thus
    * this method can be used to change the date, time or offset: <pre> result =
    * localDateTime.with(date); result = localDateTime.with(time); </pre>
    *
@@ -823,7 +823,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code LocalDateTime} based on { @code this} with the adjustment made, not null
+   *   a {@code LocalDateTime} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -841,7 +841,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Returns a copy of this date-time with the specified field set to a new value.
    *
-   * This returns a new {@code LocalDateTime}, based on this one, with the value for the specified
+   * This returns a new {@code LocalDateTime} , based on this one, with the value for the specified
    * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
@@ -854,9 +854,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * If the field is a {@link ChronoField} then the adjustment is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will behave as per the matching method on {@link
    * LocalDate#with(TemporalField, long) LocalDate} or {@link LocalTime#with(TemporalField, long)
-   * LocalTime}. All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * LocalTime}. All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -867,7 +867,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code LocalDateTime} based on { @code this} with the specified field set, not null
+   *   a {@code LocalDateTime} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -891,7 +891,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested year, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -907,7 +907,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested month, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -923,7 +923,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested day, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -940,7 +940,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   a { @code LocalDateTime} based on this date with the requested day, not null
+   *   a {@code LocalDateTime} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -956,7 +956,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested hour, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -971,7 +971,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested minute, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -988,7 +988,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested second, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -1005,7 +1005,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested nanosecond, not null
+   *   a {@code LocalDateTime} based on this date-time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nano value is invalid
    */
@@ -1023,14 +1023,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the time truncated, not null
+   *   a {@code LocalDateTime} based on this date-time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -1042,14 +1042,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * This method returns a new date-time based on this time with the specified period added. The
    * amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #plus(long, TemporalUnit)}.
+   * typically calls back to {@link #plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the addition made, not null
+   *   a {@code LocalDateTime} based on this date-time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -1073,7 +1073,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the specified period added, not null
+   *   a {@code LocalDateTime} based on this date-time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1114,7 +1114,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param years
    *   the years to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the years added, not null
+   *   a {@code LocalDateTime} based on this date-time with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1138,7 +1138,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param months
    *   the months to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the months added, not null
+   *   a {@code LocalDateTime} based on this date-time with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1161,7 +1161,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param weeks
    *   the weeks to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the weeks added, not null
+   *   a {@code LocalDateTime} based on this date-time with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1184,7 +1184,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param days
    *   the days to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the days added, not null
+   *   a {@code LocalDateTime} based on this date-time with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1201,7 +1201,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the hours added, not null
+   *   a {@code LocalDateTime} based on this date-time with the hours added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1215,7 +1215,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the minutes added, not null
+   *   a {@code LocalDateTime} based on this date-time with the minutes added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1229,7 +1229,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the seconds added, not null
+   *   a {@code LocalDateTime} based on this date-time with the seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1243,7 +1243,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the nanoseconds added, not null
+   *   a {@code LocalDateTime} based on this date-time with the nanoseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1255,14 +1255,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * This method returns a new date-time based on this time with the specified period subtracted.
    * The amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@link #minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the subtraction made, not null
+   *   a {@code LocalDateTime} based on this date-time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1286,7 +1286,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the specified period subtracted, not
+   *   a {@code LocalDateTime} based on this date-time with the specified period subtracted, not
    *   null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
@@ -1311,7 +1311,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param years
    *   the years to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the years subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1334,7 +1334,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param months
    *   the months to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the months subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1356,7 +1356,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param weeks
    *   the weeks to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the weeks subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1378,7 +1378,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param days
    *   the days to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the days subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1394,7 +1394,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the hours subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the hours subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1408,7 +1408,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the minutes subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the minutes subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1422,7 +1422,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the seconds subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1437,7 +1437,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the nanoseconds subtracted, not null
+   *   a {@code LocalDateTime} based on this date-time with the nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1545,7 +1545,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This calculates the period between two date-times in terms of a single unit. The start and end
    * points are {@code this} and the specified date-time. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code LocalDateTime}.
+   * before the start. The {@code Temporal} passed to this method must be a {@code LocalDateTime} .
    * For example, the period in days between two date-times can be calculated using {@code
    * startDateTime.until(endDateTime, DAYS)}.
    *
@@ -1553,26 +1553,26 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * two date-times. For example, the period in months between 2012-06-15T00:00 and 2012-08-14T23:59
    * will only be one month as it is one minute short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS}, {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code
-   * CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values
-   * will throw an exception.
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code NANOS}
+   * , {@code MICROS} , {@code MILLIS} , {@code SECONDS} , {@code MINUTES} , {@code HOURS} and
+   * {@code HALF_DAYS}, {@code DAYS} , {@code WEEKS} , {@code MONTHS} , {@code YEARS} ,
+   * {@code DECADES} , {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other
+   * {@code ChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date-time, which is converted to a { @code LocalDateTime}, not null
+   *   the end date-time, which is converted to a {@code LocalDateTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1641,7 +1641,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Combines this date-time with an offset to create an {@code OffsetDateTime}.
+   * Combines this date-time with an offset to create an {@code OffsetDateTime} .
    *
    * This returns an {@code OffsetDateTime} formed from this date-time at the specified offset. All
    * possible combinations of date-time and offset are valid.
@@ -1654,7 +1654,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def atOffset(offset: ZoneOffset): OffsetDateTime = OffsetDateTime.of(this, offset)
 
   /**
-   * Combines this date-time with a time-zone to create a {@code ZonedDateTime}.
+   * Combines this date-time with a time-zone to create a {@code ZonedDateTime} .
    *
    * This returns a {@code ZonedDateTime} formed from this date-time at the specified time-zone. The
    * result will match this date-time as closely as possible. Time-zone rules, such as daylight
@@ -1709,9 +1709,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * Compares this date-time to another date-time.
    *
    * The comparison is primarily based on the date-time, from earliest to latest. It is "consistent
-   * with equals", as defined by {@link Comparable}.
+   * with equals", as defined by {@link Comparable} .
    *
-   * If all the date-times being compared are instances of {@code LocalDateTime}, then the
+   * If all the date-times being compared are instances of {@code LocalDateTime} , then the
    * comparison will be entirely based on the date-time. If some dates being compared are in
    * different chronologies, then the chronology is also considered, see {@link
    * ChronoLocalDateTime#compareTo}.
@@ -1739,13 +1739,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This checks to see if this date-time represents a point on the local time-line after the other
    * date-time. <pre> LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00); LocalDate b =
-   * LocalDateTime.of(2012, 7, 1, 12, 00);
-   * a.isAfter(b) == false
-   * a.isAfter(a) == false b.isAfter(a) == true </pre>
+   * LocalDateTime.of(2012, 7, 1, 12, 00); a.isAfter(b) == false a.isAfter(a) == false b.isAfter(a)
+   * \== true </pre>
    *
    * This method only considers the position of the two date-times on the local time-line. It does
    * not take into account the chronology, or calendar system. This is different from the comparison
-   * in {@link #compareTo(ChronoLocalDateTime)}, but is the same approach as {@link
+   * in {@link #compareTo(ChronoLocalDateTime)} , but is the same approach as {@link
    * #DATE_TIME_COMPARATOR}.
    *
    * @param other
@@ -1764,13 +1763,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This checks to see if this date-time represents a point on the local time-line before the other
    * date-time. <pre> LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00); LocalDate b =
-   * LocalDateTime.of(2012, 7, 1, 12, 00);
-   * a.isBefore(b) == true
-   * a.isBefore(a) == false b.isBefore(a) == false </pre>
+   * LocalDateTime.of(2012, 7, 1, 12, 00); a.isBefore(b) == true a.isBefore(a) == false
+   * b.isBefore(a) == false </pre>
    *
    * This method only considers the position of the two date-times on the local time-line. It does
    * not take into account the chronology, or calendar system. This is different from the comparison
-   * in {@link #compareTo(ChronoLocalDateTime)}, but is the same approach as {@link
+   * in {@link #compareTo(ChronoLocalDateTime)} , but is the same approach as {@link
    * #DATE_TIME_COMPARATOR}.
    *
    * @param other
@@ -1789,13 +1787,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This checks to see if this date-time represents the same point on the local time-line as the
    * other date-time. <pre> LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00); LocalDate b =
-   * LocalDateTime.of(2012, 7, 1, 12, 00);
-   * a.isEqual(b) == false
-   * a.isEqual(a) == true b.isEqual(a) == false </pre>
+   * LocalDateTime.of(2012, 7, 1, 12, 00); a.isEqual(b) == false a.isEqual(a) == true b.isEqual(a)
+   * \== false </pre>
    *
    * This method only considers the position of the two date-times on the local time-line. It does
    * not take into account the chronology, or calendar system. This is different from the comparison
-   * in {@link #compareTo(ChronoLocalDateTime)}, but is the same approach as {@link
+   * in {@link #compareTo(ChronoLocalDateTime)} , but is the same approach as {@link
    * #DATE_TIME_COMPARATOR}.
    *
    * @param other
@@ -1835,7 +1832,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   override def hashCode: Int = date.hashCode ^ time.hashCode
 
   /**
-   * Outputs this date-time as a {@code String}, such as {@code 2007-12-03T10:15:30}.
+   * Outputs this date-time as a {@code String} , such as {@code 2007-12-03T10:15:30} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code
    * yyyy-MM-dd'T'HH:mm}</li> <li>{@code yyyy-MM-dd'T'HH:mm:ss}</li> <li>{@code
diff --git a/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala b/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala
index 987ddb29d..9836d542b 100644
--- a/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala
@@ -69,13 +69,13 @@ object LocalTime {
   }
 
   /**
-   * The minimum supported {@code LocalTime}, '00:00'. This is the time of midnight at the start of
+   * The minimum supported {@code LocalTime} , '00:00'. This is the time of midnight at the start of
    * the day.
    */
   lazy val MIN: LocalTime = HOURS(0)
 
   /**
-   * The maximum supported {@code LocalTime}, '23:59:59.999999999'. This is the time just before
+   * The maximum supported {@code LocalTime} , '23:59:59.999999999'. This is the time just before
    * midnight at the end of the day.
    */
   lazy val MAX: LocalTime = new LocalTime(23, 59, 59, 999999999)
@@ -260,7 +260,7 @@ object LocalTime {
    * This factory may return a cached value, but applications must not rely on this.
    *
    * @param secondOfDay
-   *   the second-of-day, from { @code 0} to { @code 24 * 60 * 60 - 1}
+   *   the second-of-day, from {@code 0} to {@code 24 * 60 * 60 - 1}
    * @return
    *   the local time, not null
    * @throws DateTimeException
@@ -283,7 +283,7 @@ object LocalTime {
    * This factory may return a cached value, but applications must not rely on this.
    *
    * @param secondOfDay
-   *   the second-of-day, from { @code 0} to { @code 24 * 60 * 60 - 1}
+   *   the second-of-day, from {@code 0} to {@code 24 * 60 * 60 - 1}
    * @param nanoOfSecond
    *   the nano-of-second, from 0 to 999,999,999
    * @return
@@ -308,7 +308,7 @@ object LocalTime {
    * This factory may return a cached value, but applications must not rely on this.
    *
    * @param nanoOfDay
-   *   the nano of day, from { @code 0} to { @code 24 * 60 * 60 * 1,000,000,000 - 1}
+   *   the nano of day, from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1}
    * @return
    *   the local time, not null
    * @throws DateTimeException
@@ -330,20 +330,20 @@ object LocalTime {
    * Obtains an instance of {@code LocalTime} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code LocalTime}.
+   * converts the arbitrary temporal object to an instance of {@code LocalTime} .
    *
    * The conversion uses the {@link TemporalQueries#localTime()} query, which relies on extracting
    * the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY} field.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code LocalTime::from}.
+   * to be used in queries via method reference, {@code LocalTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the local time, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code LocalTime}
+   *   if unable to convert to a {@code LocalTime}
    */
   def from(temporal: TemporalAccessor): LocalTime = {
     val time: LocalTime = temporal.query(TemporalQueries.localTime)
@@ -356,7 +356,7 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from a text string such as {@code 10:15}.
+   * Obtains an instance of {@code LocalTime} from a text string such as {@code 10:15} .
    *
    * The string must represent a valid time and is parsed using {@link
    * org.threeten.bp.format.DateTimeFormatter#ISO_LOCAL_TIME}.
@@ -417,11 +417,11 @@ object LocalTime {
 }
 
 /**
- * A time without time-zone in the ISO-8601 calendar system, such as {@code 10:15:30}.
+ * A time without time-zone in the ISO-8601 calendar system, such as {@code 10:15:30} .
  *
  * {@code LocalTime} is an immutable date-time object that represents a time, often viewed as
  * hour-minute-second. Time is represented to nanosecond precision. For example, the value
- * "13:45.30.123456789" can be stored in a {@code LocalTime}.
+ * "13:45.30.123456789" can be stored in a {@code LocalTime} .
  *
  * It does not store or represent a date or time-zone. Instead, it is a description of the local
  * time as seen on a wall clock. It cannot represent an instant on the time-line without additional
@@ -476,7 +476,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * <li>{@code CLOCK_HOUR_OF_DAY} <li>{@code AMPM_OF_DAY} </ul> All other {@code ChronoField}
    * instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -502,9 +502,9 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -518,7 +518,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   override def range(field: TemporalField): ValueRange = super.range(field)
 
   /**
-   * Gets the value of the specified field from this time as an {@code int}.
+   * Gets the value of the specified field from this time as an {@code int} .
    *
    * This queries this time for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
@@ -527,10 +527,10 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time,
    * except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY} which are too large to fit in an {@code
-   * int} and throw a {@code DateTimeException}. All other {@code ChronoField} instances will throw
-   * a {@code DateTimeException}.
+   * int} and throw a {@code DateTimeException} . All other {@code ChronoField} instances will throw
+   * a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -548,16 +548,16 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     else super.get(field)
 
   /**
-   * Gets the value of the specified field from this time as a {@code long}.
+   * Gets the value of the specified field from this time as a {@code long} .
    *
    * This queries this time for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -637,9 +637,9 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   /**
    * Returns an adjusted copy of this time.
    *
-   * This returns a new {@code LocalTime}, based on this one, with the time adjusted. The adjustment
-   * takes place using the specified adjuster strategy object. Read the documentation of the
-   * adjuster to understand what adjustment will be made.
+   * This returns a new {@code LocalTime} , based on this one, with the time adjusted. The
+   * adjustment takes place using the specified adjuster strategy object. Read the documentation of
+   * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the hour field. A more
    * complex adjuster might set the time to the last hour of the day.
@@ -653,7 +653,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code LocalTime} based on { @code this} with the adjustment made, not null
+   *   a {@code LocalTime} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -668,16 +668,16 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   /**
    * Returns a copy of this time with the specified field set to a new value.
    *
-   * This returns a new {@code LocalTime}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the hour, minute or second. If
-   * it is not possible to set the value, because the field is not supported or for some other
-   * reason, an exception is thrown.
+   * This returns a new {@code LocalTime} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the hour, minute or
+   * second. If it is not possible to set the value, because the field is not supported or for some
+   * other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
    * fields behave as follows: <ul> <li>{@code NANO_OF_SECOND} - Returns a {@code LocalTime} with
    * the specified nano-of-second. The hour, minute and second will be unchanged. <li>{@code
    * NANO_OF_DAY} - Returns a {@code LocalTime} with the specified nano-of-day. This completely
-   * replaces the time and is equivalent to {@link #ofNanoOfDay(long)}. <li>{@code MICRO_OF_SECOND}
+   * replaces the time and is equivalent to {@link #ofNanoOfDay(long)} . <li>{@code MICRO_OF_SECOND}
    *   - Returns a {@code LocalTime} with the nano-of-second replaced by the specified
    *     micro-of-second multiplied by 1,000. The hour, minute and second will be unchanged.
    *     <li>{@code MICRO_OF_DAY} - Returns a {@code LocalTime} with the specified micro-of-day.
@@ -709,9 +709,9 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -722,7 +722,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code LocalTime} based on { @code this} with the specified field set, not null
+   *   a {@code LocalTime} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -763,7 +763,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   a { @code LocalTime} based on this time with the requested hour, not null
+   *   a {@code LocalTime} based on this time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -783,7 +783,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalTime} based on this time with the requested minute, not null
+   *   a {@code LocalTime} based on this time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -803,7 +803,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalTime} based on this time with the requested second, not null
+   *   a {@code LocalTime} based on this time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -823,7 +823,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   a { @code LocalTime} based on this time with the requested nanosecond, not null
+   *   a {@code LocalTime} based on this time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nanos value is invalid
    */
@@ -844,14 +844,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    *
    * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   a { @code LocalTime} based on this time with the time truncated, not null
+   *   a {@code LocalTime} based on this time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -874,14 +874,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * This method returns a new time based on this time with the specified period added. The amount
    * is typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}.
+   * to {@link #plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code LocalTime} based on this time with the addition made, not null
+   *   a {@code LocalTime} based on this time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -904,7 +904,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code LocalTime} based on this time with the specified period added, not null
+   *   a {@code LocalTime} based on this time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -937,7 +937,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param hoursToAdd
    *   the hours to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the hours added, not null
+   *   a {@code LocalTime} based on this time with the hours added, not null
    */
   def plusHours(hoursToAdd: Long): LocalTime = {
     if (hoursToAdd == 0)
@@ -958,7 +958,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param minutesToAdd
    *   the minutes to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the minutes added, not null
+   *   a {@code LocalTime} based on this time with the minutes added, not null
    */
   def plusMinutes(minutesToAdd: Long): LocalTime = {
     if (minutesToAdd == 0)
@@ -984,7 +984,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param secondstoAdd
    *   the seconds to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the seconds added, not null
+   *   a {@code LocalTime} based on this time with the seconds added, not null
    */
   def plusSeconds(secondstoAdd: Long): LocalTime = {
     if (secondstoAdd == 0)
@@ -1012,7 +1012,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param nanosToAdd
    *   the nanos to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the nanoseconds added, not null
+   *   a {@code LocalTime} based on this time with the nanoseconds added, not null
    */
   def plusNanos(nanosToAdd: Long): LocalTime = {
     if (nanosToAdd == 0)
@@ -1036,14 +1036,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * This method returns a new time based on this time with the specified period subtracted. The
    * amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@link #minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code LocalTime} based on this time with the subtraction made, not null
+   *   a {@code LocalTime} based on this time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1067,7 +1067,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code LocalTime} based on this time with the specified period subtracted, not null
+   *   a {@code LocalTime} based on this time with the specified period subtracted, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1086,7 +1086,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param hoursToSubtract
    *   the hours to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the hours subtracted, not null
+   *   a {@code LocalTime} based on this time with the hours subtracted, not null
    */
   def minusHours(hoursToSubtract: Long): LocalTime =
     plusHours(-(hoursToSubtract % LocalTime.HOURS_PER_DAY))
@@ -1102,7 +1102,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param minutesToSubtract
    *   the minutes to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the minutes subtracted, not null
+   *   a {@code LocalTime} based on this time with the minutes subtracted, not null
    */
   def minusMinutes(minutesToSubtract: Long): LocalTime =
     plusMinutes(-(minutesToSubtract % LocalTime.MINUTES_PER_DAY))
@@ -1118,7 +1118,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param secondsToSubtract
    *   the seconds to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the seconds subtracted, not null
+   *   a {@code LocalTime} based on this time with the seconds subtracted, not null
    */
   def minusSeconds(secondsToSubtract: Long): LocalTime =
     plusSeconds(-(secondsToSubtract % LocalTime.SECONDS_PER_DAY))
@@ -1134,7 +1134,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param nanosToSubtract
    *   the nanos to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the nanoseconds subtracted, not null
+   *   a {@code LocalTime} based on this time with the nanoseconds subtracted, not null
    */
   def minusNanos(nanosToSubtract: Long): LocalTime =
     plusNanos(-(nanosToSubtract % LocalTime.NANOS_PER_DAY))
@@ -1203,7 +1203,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    *
    * This calculates the period between two times in terms of a single unit. The start and end
    * points are {@code this} and the specified time. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code LocalTime}. For
+   * before the start. The {@code Temporal} passed to this method must be a {@code LocalTime} . For
    * example, the period in hours between two times can be calculated using {@code
    * startTime.until(endTime, HOURS)}.
    *
@@ -1211,24 +1211,24 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * two times. For example, the period in hours between 11:30 and 13:29 will only be one hour as it
    * is one minute short of two hours.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, HOURS); // this method dateTime.plus(HOURS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception.
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code NANOS}
+   * , {@code MICROS} , {@code MILLIS} , {@code SECONDS} , {@code MINUTES} , {@code HOURS} and
+   * {@code HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end time, which is converted to a { @code LocalTime}, not null
+   *   the end time, which is converted to a {@code LocalTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1260,7 +1260,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Combines this time with a date to create a {@code LocalDateTime}.
+   * Combines this time with a date to create a {@code LocalDateTime} .
    *
    * This returns a {@code LocalDateTime} formed from this time at the specified date. All possible
    * combinations of date and time are valid.
@@ -1273,7 +1273,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   def atDate(date: LocalDate): LocalDateTime = LocalDateTime.of(date, this)
 
   /**
-   * Combines this time with an offset to create an {@code OffsetTime}.
+   * Combines this time with an offset to create an {@code OffsetTime} .
    *
    * This returns an {@code OffsetTime} formed from this time at the specified offset. All possible
    * combinations of time and offset are valid.
@@ -1286,7 +1286,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   def atOffset(offset: ZoneOffset): OffsetTime = OffsetTime.of(this, offset)
 
   /**
-   * Extracts the time as seconds of day, from {@code 0} to {@code 24 * 60 * 60 - 1}.
+   * Extracts the time as seconds of day, from {@code 0} to {@code 24 * 60 * 60 - 1} .
    *
    * @return
    *   the second-of-day equivalent to this time
@@ -1299,7 +1299,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Extracts the time as nanos of day, from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1}.
+   * Extracts the time as nanos of day, from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1} .
    *
    * @return
    *   the nano of day equivalent to this time
@@ -1316,14 +1316,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * Compares this {@code LocalTime} to another time.
    *
    * The comparison is based on the time-line position of the local times within a day. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@link Comparable} .
    *
    * @param other
    *   the other time to compare to, not null
    * @return
    *   the comparator value, negative if less, positive if greater
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@code other} is null
    */
   def compare(other: LocalTime): Int = {
     var cmp: Int = Integer.compare(hour.toInt, other.hour.toInt)
@@ -1350,7 +1350,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @return
    *   true if this is after the specified time
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@code other} is null
    */
   def isAfter(other: LocalTime): Boolean = compareTo(other) > 0
 
@@ -1364,7 +1364,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @return
    *   true if this point is before the specified time
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@code other} is null
    */
   def isBefore(other: LocalTime): Boolean = compareTo(other) < 0
 
@@ -1401,7 +1401,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Outputs this time as a {@code String}, such as {@code 10:15}.
+   * Outputs this time as a {@code String} , such as {@code 10:15} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code HH:mm}</li>
    * <li>{@code HH:mm:ss}</li> <li>{@code HH:mm:ss.SSS}</li> <li>{@code HH:mm:ss.SSSSSS}</li>
diff --git a/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala b/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala
index 3f607d5b3..8d8bab304 100644
--- a/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala
@@ -108,7 +108,7 @@ object MonthDay {
   }
 
   /**
-   * Obtains an instance of {@code MonthDay}.
+   * Obtains an instance of {@code MonthDay} .
    *
    * The day-of-month must be valid for the month within a leap year. Hence, for February, day 29 is
    * valid.
@@ -139,7 +139,7 @@ object MonthDay {
   }
 
   /**
-   * Obtains an instance of {@code MonthDay}.
+   * Obtains an instance of {@code MonthDay} .
    *
    * The day-of-month must be valid for the month within a leap year. Hence, for month 2 (February),
    * day 29 is valid.
@@ -165,21 +165,21 @@ object MonthDay {
    * Obtains an instance of {@code MonthDay} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code MonthDay}.
+   * converts the arbitrary temporal object to an instance of {@code MonthDay} .
    *
    * The conversion extracts the {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
    * ChronoField#DAY_OF_MONTH DAY_OF_MONTH} fields. The extraction is only permitted if the
    * date-time has an ISO chronology.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code MonthDay::from}.
+   * to be used in queries via method reference, {@code MonthDay::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the month-day, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code MonthDay}
+   *   if unable to convert to a {@code MonthDay}
    */
   def from(temporal: TemporalAccessor): MonthDay = {
     var _temporal = temporal
@@ -201,9 +201,9 @@ object MonthDay {
   }
 
   /**
-   * Obtains an instance of {@code MonthDay} from a text string such as {@code --12-03}.
+   * Obtains an instance of {@code MonthDay} from a text string such as {@code --12-03} .
    *
-   * The string must represent a valid month-day. The format is {@code --MM-dd}.
+   * The string must represent a valid month-day. The format is {@code --MM-dd} .
    *
    * @param text
    *   the text to parse such as "--12-03", not null
@@ -241,22 +241,22 @@ object MonthDay {
 }
 
 /**
- * A month-day in the ISO-8601 calendar system, such as {@code --12-03}.
+ * A month-day in the ISO-8601 calendar system, such as {@code --12-03} .
  *
  * {@code MonthDay} is an immutable date-time object that represents the combination of a year and
  * month. Any field that can be derived from a month and day, such as quarter-of-year, can be
  * obtained.
  *
  * This class does not store or represent a year, time or time-zone. For example, the value
- * "December 3rd" can be stored in a {@code MonthDay}.
+ * "December 3rd" can be stored in a {@code MonthDay} .
  *
  * Since a {@code MonthDay} does not possess a year, the leap day of February 29th is considered
  * valid.
  *
- * This class implements {@link TemporalAccessor} rather than {@link Temporal}. This is because it
+ * This class implements {@link TemporalAccessor} rather than {@link Temporal} . This is because it
  * is not possible to define whether February 29th is valid or not without external information,
  * preventing the implementation of plus/minus. Related to this, {@code MonthDay} only provides
- * access to query and set the fields {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH}.
+ * access to query and set the fields {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} .
  *
  * The ISO-8601 calendar system is the modern civil calendar system used today in most of the world.
  * It is equivalent to the proleptic Gregorian calendar system, in which today's rules for leap
@@ -293,7 +293,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * The supported fields are: <ul> <li>{@code MONTH_OF_YEAR} <li>{@code YEAR} </ul> All other
    * {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -317,9 +317,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -342,7 +342,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this month-day as an {@code int}.
+   * Gets the value of the specified field from this month-day as an {@code int} .
    *
    * This queries this month-day for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -350,9 +350,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this month-day.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -369,7 +369,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
     range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this month-day as a {@code long}.
+   * Gets the value of the specified field from this month-day as a {@code long} .
    *
    * This queries this month-day for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -377,9 +377,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this month-day.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -407,7 +407,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * Gets the month-of-year field from 1 to 12.
    *
    * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * clearer if the enum {@link Month} is used by calling {@link #getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -421,7 +421,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    *
    * This method returns the enum {@link Month} for the month. This avoids confusion as to what
    * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * provides the {@link Month#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -466,7 +466,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * @param month
    *   the month-of-year to set in the returned month-day, from 1 (January) to 12 (December)
    * @return
-   *   a { @code MonthDay} based on this month-day with the requested month, not null
+   *   a {@code MonthDay} based on this month-day with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -483,7 +483,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * @param month
    *   the month-of-year to set in the returned month-day, not null
    * @return
-   *   a { @code MonthDay} based on this month-day with the requested month, not null
+   *   a {@code MonthDay} based on this month-day with the requested month, not null
    */
   def `with`(month: Month): MonthDay = {
     Objects.requireNonNull(month, "month")
@@ -504,7 +504,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * @param dayOfMonth
    *   the day-of-month to set in the return month-day, from 1 to 31
    * @return
-   *   a { @code MonthDay} based on this month-day with the requested day, not null
+   *   a {@code MonthDay} based on this month-day with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -580,7 +580,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
   }
 
   /**
-   * Combines this month-day with a year to create a {@code LocalDate}.
+   * Combines this month-day with a year to create a {@code LocalDate} .
    *
    * This returns a {@code LocalDate} formed from this month-day and the specified year.
    *
@@ -602,7 +602,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * Compares this month-day to another month-day.
    *
    * The comparison is based first on value of the month, then on the value of the day. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@link Comparable} .
    *
    * @param other
    *   the other month-day to compare to, not null
@@ -663,9 +663,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
   override def hashCode: Int = (month << 6) + day
 
   /**
-   * Outputs this month-day as a {@code String}, such as {@code --12-03}.
+   * Outputs this month-day as a {@code String} , such as {@code --12-03} .
    *
-   * The output will be in the format {@code --MM-dd}:
+   * The output will be in the format {@code --MM-dd} :
    *
    * @return
    *   a string representation of this month-day, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala
index 3c8e19955..8a575838c 100644
--- a/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala
@@ -57,7 +57,7 @@ import org.threeten.bp.zone.ZoneRules
 object OffsetDateTime {
 
   /**
-   * The minimum supported {@code OffsetDateTime}, '-999999999-01-01T00:00:00+18:00'. This is the
+   * The minimum supported {@code OffsetDateTime} , '-999999999-01-01T00:00:00+18:00'. This is the
    * local date-time of midnight at the start of the minimum date in the maximum offset (larger
    * offsets are earlier on the time-line). This combines {@link LocalDateTime#MIN} and {@link
    * ZoneOffset#MAX}. This could be used by an application as a "far past" date-time.
@@ -65,10 +65,10 @@ object OffsetDateTime {
   lazy val MIN: OffsetDateTime = LocalDateTime.MIN.atOffset(ZoneOffset.MAX)
 
   /**
-   * The maximum supported {@code OffsetDateTime}, '+999999999-12-31T23:59:59.999999999-18:00'. This
-   * is the local date-time just before midnight at the end of the maximum date in the minimum
+   * The maximum supported {@code OffsetDateTime} , '+999999999-12-31T23:59:59.999999999-18:00'.
+   * This is the local date-time just before midnight at the end of the maximum date in the minimum
    * offset (larger negative offsets are later on the time-line). This combines {@link
-   * LocalDateTime#MAX} and {@link ZoneOffset#MIN}. This could be used by an application as a "far
+   * LocalDateTime#MAX} and {@link ZoneOffset#MIN} . This could be used by an application as a "far
    * future" date-time.
    */
   lazy val MAX: OffsetDateTime = LocalDateTime.MAX.atOffset(ZoneOffset.MIN)
@@ -139,7 +139,7 @@ object OffsetDateTime {
    * calculated from the time-zone in the clock.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -263,20 +263,20 @@ object OffsetDateTime {
    * Obtains an instance of {@code OffsetDateTime} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code OffsetDateTime}.
+   * converts the arbitrary temporal object to an instance of {@code OffsetDateTime} .
    *
-   * The conversion extracts and combines {@code LocalDateTime} and {@code ZoneOffset}. If that
-   * fails it will try to extract and combine {@code Instant} and {@code ZoneOffset}.
+   * The conversion extracts and combines {@code LocalDateTime} and {@code ZoneOffset} . If that
+   * fails it will try to extract and combine {@code Instant} and {@code ZoneOffset} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code OffsetDateTime::from}.
+   * to be used in queries via method reference, {@code OffsetDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the offset date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code OffsetDateTime}
+   *   if unable to convert to an {@code OffsetDateTime}
    */
   def from(temporal: TemporalAccessor): OffsetDateTime =
     temporal match {
@@ -350,9 +350,9 @@ object OffsetDateTime {
  * {@code OffsetDateTime} is an immutable representation of a date-time with an offset. This class
  * stores all date and time fields, to a precision of nanoseconds, as well as the offset from
  * UTC/Greenwich. For example, the value "2nd October 2007 at 13:45.30.123456789 +02:00" can be
- * stored in an {@code OffsetDateTime}.
+ * stored in an {@code OffsetDateTime} .
  *
- * {@code OffsetDateTime}, {@link ZonedDateTime} and {@link Instant} all store an instant on the
+ * {@code OffsetDateTime} , {@link ZonedDateTime} and {@link Instant} all store an instant on the
  * time-line to nanosecond precision. {@code Instant} is the simplest, simply representing the
  * instant. {@code OffsetDateTime} adds to the instant the offset from UTC/Greenwich, which allows
  * the local date-time to be obtained. {@code ZonedDateTime} adds full time-zone rules.
@@ -410,7 +410,7 @@ final class OffsetDateTime private (
    * <li>{@code YEAR} <li>{@code ERA} <li>{@code INSTANT_SECONDS} <li>{@code OFFSET_SECONDS} </ul>
    * All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -435,9 +435,9 @@ final class OffsetDateTime private (
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -456,7 +456,7 @@ final class OffsetDateTime private (
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this date-time as an {@code int}.
+   * Gets the value of the specified field from this date-time as an {@code int} .
    *
    * This queries this date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -464,12 +464,12 @@ final class OffsetDateTime private (
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY}, {@code EPOCH_DAY}, {@code EPOCH_MONTH} and
+   * except {@code NANO_OF_DAY} , {@code MICRO_OF_DAY} , {@code EPOCH_DAY} , {@code EPOCH_MONTH} and
    * {@code INSTANT_SECONDS} which are too large to fit in an {@code int} and throw a {@code
    * DateTimeException}. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -495,7 +495,7 @@ final class OffsetDateTime private (
     }
 
   /**
-   * Gets the value of the specified field from this date-time as a {@code long}.
+   * Gets the value of the specified field from this date-time as a {@code long} .
    *
    * This queries this date-time for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -503,9 +503,9 @@ final class OffsetDateTime private (
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -546,8 +546,8 @@ final class OffsetDateTime private (
    *
    * This method returns an object with the same {@code LocalDateTime} and the specified {@code
    * ZoneOffset}. No calculation is needed or performed. For example, if this time represents {@code
-   * 2007-12-03T10:30+02:00} and the offset specified is {@code +03:00}, then this method will
-   * return {@code 2007-12-03T10:30+03:00}.
+   * 2007-12-03T10:30+02:00} and the offset specified is {@code +03:00} , then this method will
+   * return {@code 2007-12-03T10:30+03:00} .
    *
    * To take into account the difference between the offsets, and adjust the time fields, use {@link
    * #withOffsetSameInstant}.
@@ -557,7 +557,7 @@ final class OffsetDateTime private (
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested offset, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested offset, not null
    */
   def withOffsetSameLocal(offset: ZoneOffset): OffsetDateTime = `with`(dateTime, offset)
 
@@ -569,16 +569,16 @@ final class OffsetDateTime private (
    * adjusted by the difference between the two offsets. This will result in the old and new objects
    * representing the same instant. This is useful for finding the local time in a different offset.
    * For example, if this time represents {@code 2007-12-03T10:30+02:00} and the offset specified is
-   * {@code +03:00}, then this method will return {@code 2007-12-03T11:30+03:00}.
+   * {@code +03:00} , then this method will return {@code 2007-12-03T11:30+03:00} .
    *
-   * To change the offset without adjusting the local time use {@link #withOffsetSameLocal}.
+   * To change the offset without adjusting the local time use {@link #withOffsetSameLocal} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested offset, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested offset, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -595,8 +595,8 @@ final class OffsetDateTime private (
    *
    * This method returns the primitive {@code int} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@code get(YEAR)} . To obtain the
+   * year-of-era, use {@code get(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -607,7 +607,7 @@ final class OffsetDateTime private (
    * Gets the month-of-year field from 1 to 12.
    *
    * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * clearer if the enum {@link Month} is used by calling {@link #getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -621,7 +621,7 @@ final class OffsetDateTime private (
    *
    * This method returns the enum {@link Month} for the month. This avoids confusion as to what
    * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * provides the {@link Month#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -651,13 +651,13 @@ final class OffsetDateTime private (
   def getDayOfYear: Int = dateTime.getDayOfYear
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@code DayOfWeek} .
    *
    * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
    * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * enum provides the {@link DayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@code DayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -700,15 +700,15 @@ final class OffsetDateTime private (
   /**
    * Returns an adjusted copy of this date-time.
    *
-   * This returns a new {@code OffsetDateTime}, based on this one, with the date-time adjusted. The
+   * This returns a new {@code OffsetDateTime} , based on this one, with the date-time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@link TemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay}. The adjuster is
+   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay} . The adjuster is
    * responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -716,7 +716,7 @@ final class OffsetDateTime private (
    *
    * result = offsetDateTime.with(JULY).with(lastDayOfMonth()); </pre>
    *
-   * The classes {@link LocalDate}, {@link LocalTime} and {@link ZoneOffset} implement {@code
+   * The classes {@link LocalDate} , {@link LocalTime} and {@link ZoneOffset} implement {@code
    * TemporalAdjuster}, thus this method can be used to change the date, time or offset: <pre>
    * result = offsetDateTime.with(date); result = offsetDateTime.with(time); result =
    * offsetDateTime.with(offset); </pre>
@@ -730,7 +730,7 @@ final class OffsetDateTime private (
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   an { @code OffsetDateTime} based on { @code this} with the adjustment made, not null
+   *   an {@code OffsetDateTime} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -750,7 +750,7 @@ final class OffsetDateTime private (
   /**
    * Returns a copy of this date-time with the specified field set to a new value.
    *
-   * This returns a new {@code OffsetDateTime}, based on this one, with the value for the specified
+   * This returns a new {@code OffsetDateTime} , based on this one, with the value for the specified
    * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
@@ -771,12 +771,12 @@ final class OffsetDateTime private (
    * DateTimeException} will be thrown.
    *
    * The other {@link #isSupported(TemporalField) supported fields} will behave as per the matching
-   * method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime}. In this case, the
+   * method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime} . In this case, the
    * offset is not part of the calculation and will be unchanged.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -787,7 +787,7 @@ final class OffsetDateTime private (
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   an { @code OffsetDateTime} based on { @code this} with the specified field set, not null
+   *   an {@code OffsetDateTime} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -817,7 +817,7 @@ final class OffsetDateTime private (
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested year, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -833,7 +833,7 @@ final class OffsetDateTime private (
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested month, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -849,7 +849,7 @@ final class OffsetDateTime private (
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested day, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -867,7 +867,7 @@ final class OffsetDateTime private (
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   an { @code OffsetDateTime} based on this date with the requested day, not null
+   *   an {@code OffsetDateTime} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -886,7 +886,7 @@ final class OffsetDateTime private (
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested hour, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -902,7 +902,7 @@ final class OffsetDateTime private (
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested minute, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -918,7 +918,7 @@ final class OffsetDateTime private (
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested second, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -934,7 +934,7 @@ final class OffsetDateTime private (
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested nanosecond, not null
+   *   an {@code OffsetDateTime} based on this date-time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nanos value is invalid
    */
@@ -949,7 +949,7 @@ final class OffsetDateTime private (
    *
    * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -958,7 +958,7 @@ final class OffsetDateTime private (
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the time truncated, not null
+   *   an {@code OffsetDateTime} based on this date-time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -970,7 +970,7 @@ final class OffsetDateTime private (
    * This method returns a new date-time based on this time with the specified period added. The
    * amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #plus(long, TemporalUnit)}. The offset is not part of the
+   * typically calls back to {@link #plus(long, TemporalUnit)} . The offset is not part of the
    * calculation and will be unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -978,7 +978,7 @@ final class OffsetDateTime private (
    * @param amount
    *   the amount to add, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the addition made, not null
+   *   an {@code OffsetDateTime} based on this date-time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -1003,7 +1003,7 @@ final class OffsetDateTime private (
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the specified period added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1027,7 +1027,7 @@ final class OffsetDateTime private (
    * @param years
    *   the years to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the years added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1048,7 +1048,7 @@ final class OffsetDateTime private (
    * @param months
    *   the months to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the months added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1068,7 +1068,7 @@ final class OffsetDateTime private (
    * @param weeks
    *   the weeks to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the weeks added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1088,7 +1088,7 @@ final class OffsetDateTime private (
    * @param days
    *   the days to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the days added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1102,7 +1102,7 @@ final class OffsetDateTime private (
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the hours added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the hours added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1116,7 +1116,7 @@ final class OffsetDateTime private (
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the minutes added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the minutes added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1130,7 +1130,7 @@ final class OffsetDateTime private (
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the seconds added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1144,7 +1144,7 @@ final class OffsetDateTime private (
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the nanoseconds added, not null
+   *   an {@code OffsetDateTime} based on this date-time with the nanoseconds added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1156,7 +1156,7 @@ final class OffsetDateTime private (
    * This method returns a new date-time based on this time with the specified period subtracted.
    * The amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}. The offset is not part of the
+   * typically calls back to {@link #minus(long, TemporalUnit)} . The offset is not part of the
    * calculation and will be unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1164,7 +1164,7 @@ final class OffsetDateTime private (
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the subtraction made, not null
+   *   an {@code OffsetDateTime} based on this date-time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1189,7 +1189,7 @@ final class OffsetDateTime private (
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the specified period subtracted, not
+   *   an {@code OffsetDateTime} based on this date-time with the specified period subtracted, not
    *   null
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): OffsetDateTime =
@@ -1212,7 +1212,7 @@ final class OffsetDateTime private (
    * @param years
    *   the years to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the years subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1235,7 +1235,7 @@ final class OffsetDateTime private (
    * @param months
    *   the months to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the months subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1257,7 +1257,7 @@ final class OffsetDateTime private (
    * @param weeks
    *   the weeks to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the weeks subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1279,7 +1279,7 @@ final class OffsetDateTime private (
    * @param days
    *   the days to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the days subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1295,7 +1295,7 @@ final class OffsetDateTime private (
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the hours subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the hours subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1311,7 +1311,7 @@ final class OffsetDateTime private (
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the minutes subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the minutes subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1327,7 +1327,7 @@ final class OffsetDateTime private (
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the seconds subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1344,7 +1344,7 @@ final class OffsetDateTime private (
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the nanoseconds subtracted, not null
+   *   an {@code OffsetDateTime} based on this date-time with the nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1392,7 +1392,7 @@ final class OffsetDateTime private (
    * and time changed to be the same as this.
    *
    * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} three times,
-   * passing {@link ChronoField#EPOCH_DAY}, {@link ChronoField#NANO_OF_DAY} and {@link
+   * passing {@link ChronoField#EPOCH_DAY} , {@link ChronoField#NANO_OF_DAY} and {@link
    * ChronoField#OFFSET_SECONDS} as the fields.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
@@ -1424,9 +1424,9 @@ final class OffsetDateTime private (
    * This calculates the period between two date-times in terms of a single unit. The start and end
    * points are {@code this} and the specified date-time. The result will be negative if the end is
    * before the start. For example, the period in days between two date-times can be calculated
-   * using {@code startDateTime.until(endDateTime, DAYS)}.
+   * using {@code startDateTime.until(endDateTime, DAYS)} .
    *
-   * The {@code Temporal} passed to this method must be an {@code OffsetDateTime}. If the offset
+   * The {@code Temporal} passed to this method must be an {@code OffsetDateTime} . If the offset
    * differs between the two date-times, the specified end date-time is normalized to have the same
    * offset as this date-time.
    *
@@ -1434,26 +1434,26 @@ final class OffsetDateTime private (
    * two date-times. For example, the period in months between 2012-06-15T00:00Z and
    * 2012-08-14T23:59Z will only be one month as it is one minute short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS}, {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code
-   * CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values
-   * will throw an exception.
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code NANOS}
+   * , {@code MICROS} , {@code MILLIS} , {@code SECONDS} , {@code MINUTES} , {@code HOURS} and
+   * {@code HALF_DAYS}, {@code DAYS} , {@code WEEKS} , {@code MONTHS} , {@code YEARS} ,
+   * {@code DECADES} , {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other
+   * {@code ChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date-time, which is converted to an { @code OffsetDateTime}, not null
+   *   the end date-time, which is converted to an {@code OffsetDateTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1481,8 +1481,8 @@ final class OffsetDateTime private (
    * This avoids any problems with local time-line gaps or overlaps. The result might have different
    * values for fields such as hour, minute an even day.
    *
-   * To attempt to retain the values of the fields, use {@link #atZoneSimilarLocal(ZoneId)}. To use
-   * the offset as the zone ID, use {@link #toZonedDateTime()}.
+   * To attempt to retain the values of the fields, use {@link #atZoneSimilarLocal(ZoneId)} . To use
+   * the offset as the zone ID, use {@link #toZonedDateTime()} .
    *
    * @param zone
    *   the time-zone to use, not null
@@ -1510,7 +1510,7 @@ final class OffsetDateTime private (
    * after this method.
    *
    * To create a zoned date-time at the same instant irrespective of the local time-line, use {@link
-   * #atZoneSameInstant(ZoneId)}. To use the offset as the zone ID, use {@link #toZonedDateTime()}.
+   * #atZoneSameInstant(ZoneId)}. To use the offset as the zone ID, use {@link #toZonedDateTime()} .
    *
    * @param zone
    *   the time-zone to use, not null
@@ -1552,7 +1552,7 @@ final class OffsetDateTime private (
   def toLocalTime: LocalTime = dateTime.toLocalTime
 
   /**
-   * Converts this date-time to an {@code OffsetTime}.
+   * Converts this date-time to an {@code OffsetTime} .
    *
    * This returns an offset time with the same local time and offset.
    *
@@ -1575,10 +1575,10 @@ final class OffsetDateTime private (
   def toZonedDateTime: ZonedDateTime = ZonedDateTime.of(dateTime, offset)
 
   /**
-   * Converts this date-time to an {@code Instant}.
+   * Converts this date-time to an {@code Instant} .
    *
    * @return
-   *   an { @code Instant} representing the same instant, not null
+   *   an {@code Instant} representing the same instant, not null
    */
   def toInstant: Instant = dateTime.toInstant(offset)
 
@@ -1598,7 +1598,7 @@ final class OffsetDateTime private (
    * Compares this {@code OffsetDateTime} to another date-time.
    *
    * The comparison is based on the instant then on the local date-time. It is "consistent with
-   * equals", as defined by {@link Comparable}.
+   * equals", as defined by {@link Comparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code
    * 2008-12-03T10:30+01:00}</li> <li>{@code 2008-12-03T11:00+01:00}</li> <li>{@code
@@ -1606,7 +1606,7 @@ final class OffsetDateTime private (
    * 2008-12-03T12:00+01:00}</li> <li>{@code 2008-12-03T12:30+01:00}</li> </ol> Values #2 and #3
    * represent the same instant on the time-line. When two values represent the same instant, the
    * local date-time is compared to distinguish them. This step is needed to make the ordering
-   * consistent with {@code equals()}.
+   * consistent with {@code equals()} .
    *
    * @param other
    *   the other date-time to compare to, not null
@@ -1682,7 +1682,7 @@ final class OffsetDateTime private (
    * Checks if this date-time is equal to another date-time.
    *
    * The comparison is based on the local date-time and the offset. To compare for the same instant
-   * on the time-line, use {@link #isEqual}. Only objects of type {@code OffsetDateTime} are
+   * on the time-line, use {@link #isEqual} . Only objects of type {@code OffsetDateTime} are
    * compared, other types return false.
    *
    * @param obj
@@ -1706,7 +1706,7 @@ final class OffsetDateTime private (
   override def hashCode: Int = dateTime.hashCode ^ offset.hashCode
 
   /**
-   * Outputs this date-time as a {@code String}, such as {@code 2007-12-03T10:15:30+01:00}.
+   * Outputs this date-time as a {@code String} , such as {@code 2007-12-03T10:15:30+01:00} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code
    * yyyy-MM-dd'T'HH:mmXXXXX}</li> <li>{@code yyyy-MM-dd'T'HH:mm:ssXXXXX}</li> <li>{@code
diff --git a/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala b/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala
index 7c1d8ad7c..a5e14cf86 100644
--- a/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala
@@ -59,17 +59,17 @@ import org.threeten.bp.zone.ZoneRules
 object OffsetTime {
 
   /**
-   * The minimum supported {@code OffsetTime}, '00:00:00+18:00'. This is the time of midnight at the
-   * start of the day in the maximum offset (larger offsets are earlier on the time-line). This
-   * combines {@link LocalTime#MIN} and {@link ZoneOffset#MAX}. This could be used by an application
-   * as a "far past" date.
+   * The minimum supported {@code OffsetTime} , '00:00:00+18:00'. This is the time of midnight at
+   * the start of the day in the maximum offset (larger offsets are earlier on the time-line). This
+   * combines {@link LocalTime#MIN} and {@link ZoneOffset#MAX} . This could be used by an
+   * application as a "far past" date.
    */
   lazy val MIN: OffsetTime = LocalTime.MIN.atOffset(ZoneOffset.MAX)
 
   /**
-   * The maximum supported {@code OffsetTime}, '23:59:59.999999999-18:00'. This is the time just
+   * The maximum supported {@code OffsetTime} , '23:59:59.999999999-18:00'. This is the time just
    * before midnight at the end of the day in the minimum offset (larger negative offsets are later
-   * on the time-line). This combines {@link LocalTime#MAX} and {@link ZoneOffset#MIN}. This could
+   * on the time-line). This combines {@link LocalTime#MAX} and {@link ZoneOffset#MIN} . This could
    * be used by an application as a "far future" date.
    */
   lazy val MAX: OffsetTime = LocalTime.MAX.atOffset(ZoneOffset.MIN)
@@ -112,7 +112,7 @@ object OffsetTime {
    * from the time-zone in the clock.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -198,19 +198,19 @@ object OffsetTime {
    * Obtains an instance of {@code OffsetTime} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code OffsetTime}.
+   * converts the arbitrary temporal object to an instance of {@code OffsetTime} .
    *
-   * The conversion extracts and combines {@code LocalTime} and {@code ZoneOffset}.
+   * The conversion extracts and combines {@code LocalTime} and {@code ZoneOffset} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code OffsetTime::from}.
+   * to be used in queries via method reference, {@code OffsetTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the offset time, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code OffsetTime}
+   *   if unable to convert to an {@code OffsetTime}
    */
   def from(temporal: TemporalAccessor): OffsetTime =
     temporal match {
@@ -229,7 +229,7 @@ object OffsetTime {
     }
 
   /**
-   * Obtains an instance of {@code OffsetTime} from a text string such as {@code 10:15:30+01:00}.
+   * Obtains an instance of {@code OffsetTime} from a text string such as {@code 10:15:30+01:00} .
    *
    * The string must represent a valid time and is parsed using {@link
    * org.threeten.bp.format.DateTimeFormatter#ISO_OFFSET_TIME}.
@@ -276,7 +276,7 @@ object OffsetTime {
  * {@code OffsetTime} is an immutable date-time object that represents a time, often viewed as
  * hour-minute-second-offset. This class stores all time fields, to a precision of nanoseconds, as
  * well as a zone offset. For example, the value "13:45.30.123456789+02:00" can be stored in an
- * {@code OffsetTime}.
+ * {@code OffsetTime} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
@@ -323,7 +323,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * <li>{@code CLOCK_HOUR_OF_DAY} <li>{@code AMPM_OF_DAY} <li>{@code OFFSET_SECONDS} </ul> All
    * other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -349,9 +349,9 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -370,7 +370,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this time as an {@code int}.
+   * Gets the value of the specified field from this time as an {@code int} .
    *
    * This queries this time for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
@@ -379,10 +379,10 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time,
    * except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY} which are too large to fit in an {@code
-   * int} and throw a {@code DateTimeException}. All other {@code ChronoField} instances will throw
-   * a {@code DateTimeException}.
+   * int} and throw a {@code DateTimeException} . All other {@code ChronoField} instances will throw
+   * a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -398,16 +398,16 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   override def get(field: TemporalField): Int = super.get(field)
 
   /**
-   * Gets the value of the specified field from this time as a {@code long}.
+   * Gets the value of the specified field from this time as a {@code long} .
    *
    * This queries this time for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -443,7 +443,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    *
    * This method returns an object with the same {@code LocalTime} and the specified {@code
    * ZoneOffset}. No calculation is needed or performed. For example, if this time represents {@code
-   * 10:30+02:00} and the offset specified is {@code +03:00}, then this method will return {@code
+   * 10:30+02:00} and the offset specified is {@code +03:00} , then this method will return {@code
    * 10:30+03:00}.
    *
    * To take into account the difference between the offsets, and adjust the time fields, use {@link
@@ -454,7 +454,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the requested offset, not null
+   *   an {@code OffsetTime} based on this time with the requested offset, not null
    */
   def withOffsetSameLocal(offset: ZoneOffset): OffsetTime =
     if (offset != null && (offset == this.offset)) this
@@ -468,16 +468,16 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * adjusted by the difference between the two offsets. This will result in the old and new objects
    * representing the same instant an an implied day. This is useful for finding the local time in a
    * different offset. For example, if this time represents {@code 10:30+02:00} and the offset
-   * specified is {@code +03:00}, then this method will return {@code 11:30+03:00}.
+   * specified is {@code +03:00} , then this method will return {@code 11:30+03:00} .
    *
-   * To change the offset without adjusting the local time use {@link #withOffsetSameLocal}.
+   * To change the offset without adjusting the local time use {@link #withOffsetSameLocal} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the requested offset, not null
+   *   an {@code OffsetTime} based on this time with the requested offset, not null
    */
   def withOffsetSameInstant(offset: ZoneOffset): OffsetTime =
     if (offset == this.offset)
@@ -523,14 +523,14 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   /**
    * Returns an adjusted copy of this time.
    *
-   * This returns a new {@code OffsetTime}, based on this one, with the time adjusted. The
+   * This returns a new {@code OffsetTime} , based on this one, with the time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the hour field. A more
    * complex adjuster might set the time to the last hour of the day.
    *
-   * The classes {@link LocalTime} and {@link ZoneOffset} implement {@code TemporalAdjuster}, thus
+   * The classes {@link LocalTime} and {@link ZoneOffset} implement {@code TemporalAdjuster} , thus
    * this method can be used to change the time or offset: <pre> result = offsetTime.with(time);
    * result = offsetTime.with(offset); </pre>
    *
@@ -543,7 +543,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   an { @code OffsetTime} based on { @code this} with the adjustment made, not null
+   *   an {@code OffsetTime} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -560,7 +560,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   /**
    * Returns a copy of this time with the specified field set to a new value.
    *
-   * This returns a new {@code OffsetTime}, based on this one, with the value for the specified
+   * This returns a new {@code OffsetTime} , based on this one, with the value for the specified
    * field changed. This can be used to change any supported field, such as the hour, minute or
    * second. If it is not possible to set the value, because the field is not supported or for some
    * other reason, an exception is thrown.
@@ -575,9 +575,9 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * method on {@link LocalTime#with(TemporalField, long)} LocalTime}. In this case, the offset is
    * not part of the calculation and will be unchanged.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -588,7 +588,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   an { @code OffsetTime} based on { @code this} with the specified field set, not null
+   *   an {@code OffsetTime} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -613,7 +613,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   an { @code OffsetTime} based on this time with the requested hour, not null
+   *   an {@code OffsetTime} based on this time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -629,7 +629,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetTime} based on this time with the requested minute, not null
+   *   an {@code OffsetTime} based on this time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -645,7 +645,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetTime} based on this time with the requested second, not null
+   *   an {@code OffsetTime} based on this time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -661,7 +661,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   an { @code OffsetTime} based on this time with the requested nanosecond, not null
+   *   an {@code OffsetTime} based on this time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nanos value is invalid
    */
@@ -676,7 +676,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    *
    * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -685,7 +685,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the time truncated, not null
+   *   an {@code OffsetTime} based on this time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -697,7 +697,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * This method returns a new time based on this time with the specified period added. The amount
    * is typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}. The offset is not part of the calculation and will be
+   * to {@link #plus(long, TemporalUnit)} . The offset is not part of the calculation and will be
    * unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -705,7 +705,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param amount
    *   the amount to add, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the addition made, not null
+   *   an {@code OffsetTime} based on this time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -730,7 +730,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the specified period added, not null
+   *   an {@code OffsetTime} based on this time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -749,7 +749,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the hours added, not null
+   *   an {@code OffsetTime} based on this time with the hours added, not null
    */
   def plusHours(hours: Long): OffsetTime = `with`(time.plusHours(hours), offset)
 
@@ -764,7 +764,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the minutes added, not null
+   *   an {@code OffsetTime} based on this time with the minutes added, not null
    */
   def plusMinutes(minutes: Long): OffsetTime = `with`(time.plusMinutes(minutes), offset)
 
@@ -779,7 +779,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the seconds added, not null
+   *   an {@code OffsetTime} based on this time with the seconds added, not null
    */
   def plusSeconds(seconds: Long): OffsetTime = `with`(time.plusSeconds(seconds), offset)
 
@@ -794,7 +794,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the nanoseconds added, not null
+   *   an {@code OffsetTime} based on this time with the nanoseconds added, not null
    */
   def plusNanos(nanos: Long): OffsetTime = `with`(time.plusNanos(nanos), offset)
 
@@ -804,7 +804,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * This method returns a new time based on this time with the specified period subtracted. The
    * amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}. The offset is not part of the
+   * typically calls back to {@link #minus(long, TemporalUnit)} . The offset is not part of the
    * calculation and will be unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -812,7 +812,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the subtraction made, not null
+   *   an {@code OffsetTime} based on this time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -837,7 +837,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the specified period subtracted, not null
+   *   an {@code OffsetTime} based on this time with the specified period subtracted, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -856,7 +856,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the hours subtracted, not null
+   *   an {@code OffsetTime} based on this time with the hours subtracted, not null
    */
   def minusHours(hours: Long): OffsetTime = `with`(time.minusHours(hours), offset)
 
@@ -871,7 +871,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the minutes subtracted, not null
+   *   an {@code OffsetTime} based on this time with the minutes subtracted, not null
    */
   def minusMinutes(minutes: Long): OffsetTime = `with`(time.minusMinutes(minutes), offset)
 
@@ -886,7 +886,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the seconds subtracted, not null
+   *   an {@code OffsetTime} based on this time with the seconds subtracted, not null
    */
   def minusSeconds(seconds: Long): OffsetTime = `with`(time.minusSeconds(seconds), offset)
 
@@ -901,7 +901,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the nanoseconds subtracted, not null
+   *   an {@code OffsetTime} based on this time with the nanoseconds subtracted, not null
    */
   def minusNanos(nanos: Long): OffsetTime = `with`(time.minusNanos(nanos), offset)
 
@@ -973,34 +973,34 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * This calculates the period between two times in terms of a single unit. The start and end
    * points are {@code this} and the specified time. The result will be negative if the end is
    * before the start. For example, the period in hours between two times can be calculated using
-   * {@code startTime.until(endTime, HOURS)}.
+   * {@code startTime.until(endTime, HOURS)} .
    *
-   * The {@code Temporal} passed to this method must be an {@code OffsetTime}. If the offset differs
-   * between the two times, then the specified end time is normalized to have the same offset as
-   * this time.
+   * The {@code Temporal} passed to this method must be an {@code OffsetTime} . If the offset
+   * differs between the two times, then the specified end time is normalized to have the same
+   * offset as this time.
    *
    * The calculation returns a whole number, representing the number of complete units between the
    * two times. For example, the period in hours between 11:30Z and 13:29Z will only be one hour as
    * it is one minute short of two hours.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, HOURS); // this method dateTime.plus(HOURS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception.
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code NANOS}
+   * , {@code MICROS} , {@code MILLIS} , {@code SECONDS} , {@code MINUTES} , {@code HOURS} and
+   * {@code HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end time, which is converted to an { @code OffsetTime}, not null
+   *   the end time, which is converted to an {@code OffsetTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1032,7 +1032,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   }
 
   /**
-   * Combines this time with a date to create an {@code OffsetDateTime}.
+   * Combines this time with a date to create an {@code OffsetDateTime} .
    *
    * This returns an {@code OffsetDateTime} formed from this time and the specified date. All
    * possible combinations of date and time are valid.
@@ -1071,7 +1071,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Compares this {@code OffsetTime} to another time.
    *
    * The comparison is based first on the UTC equivalent instant, then on the local time. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@link Comparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code 10:30+01:00}</li>
    * <li>{@code 11:00+01:00}</li> <li>{@code 12:00+02:00}</li> <li>{@code 11:30+01:00}</li>
@@ -1088,7 +1088,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @return
    *   the comparator value, negative if less, positive if greater
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@code other} is null
    */
   def compare(other: OffsetTime): Int =
     if (offset == other.offset)
@@ -1151,7 +1151,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Checks if this time is equal to another time.
    *
    * The comparison is based on the local-time and the offset. To compare for the same instant on
-   * the time-line, use {@link #isEqual(OffsetTime)}.
+   * the time-line, use {@link #isEqual(OffsetTime)} .
    *
    * Only objects of type {@code OffsetTime} are compared, other types return false. To compare the
    * underlying local time of two {@code TemporalAccessor} instances, use {@link
@@ -1177,7 +1177,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   override def hashCode: Int = time.hashCode ^ offset.hashCode
 
   /**
-   * Outputs this time as a {@code String}, such as {@code 10:15:30+01:00}.
+   * Outputs this time as a {@code String} , such as {@code 10:15:30+01:00} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code HH:mmXXXXX}</li>
    * <li>{@code HH:mm:ssXXXXX}</li> <li>{@code HH:mm:ss.SSSXXXXX}</li> <li>{@code
diff --git a/core/shared/src/main/scala/org/threeten/bp/Period.scala b/core/shared/src/main/scala/org/threeten/bp/Period.scala
index 4bbfddc50..bced5d3c3 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Period.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Period.scala
@@ -143,7 +143,7 @@ object Period {
    * @return
    *   the equivalent period, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Period}
+   *   if unable to convert to a {@code Period}
    * @throws ArithmeticException
    *   if the amount of years, months or days exceeds an int
    */
@@ -202,10 +202,10 @@ object Period {
   def between(startDate: LocalDate, endDate: LocalDate): Period = startDate.until(endDate)
 
   /**
-   * Obtains a {@code Period} from a text string such as {@code PnYnMnD}.
+   * Obtains a {@code Period} from a text string such as {@code PnYnMnD} .
    *
    * This will parse the string produced by {@code toString()} which is based on the ISO-8601 period
-   * formats {@code PnYnMnD} and {@code PnW}.
+   * formats {@code PnYnMnD} and {@code PnW} .
    *
    * The string starts with an optional sign, denoted by the ASCII negative or positive symbol. If
    * negative, the whole period is negated. The ASCII letter "P" is next in upper or lower case.
@@ -213,7 +213,7 @@ object Period {
    * four sections must be present. The sections have suffixes in ASCII of "Y", "M", "W" and "D" for
    * years, months, weeks and days, accepted in upper or lower case. The suffixes must occur in
    * order. The number part of each section must consist of ASCII digits. The number may be prefixed
-   * by the ASCII negative or positive symbol. The number must parse to an {@code int}.
+   * by the ASCII negative or positive symbol. The number must parse to an {@code int} .
    *
    * The leading plus/minus sign, and negative values for other units are not part of the ISO-8601
    * standard. In addition, ISO-8601 does not permit mixing between the {@code PnYnMnD} and {@code
@@ -299,8 +299,8 @@ object Period {
  * exactly 24 hours, resulting in a {@code ZonedDateTime} at 19:00 the following day (assuming a one
  * hour DST gap).
  *
- * The supported units of a period are {@link ChronoUnit#YEARS YEARS}, {@link ChronoUnit#MONTHS
- * MONTHS} and {@link ChronoUnit#DAYS DAYS}. All three fields are always present, but may be set to
+ * The supported units of a period are {@link ChronoUnit#YEARS YEARS} , {@link ChronoUnit#MONTHS
+ * MONTHS} and {@link ChronoUnit#DAYS DAYS} . All three fields are always present, but may be set to
  * zero.
  *
  * The period may be used with any calendar system. The meaning of a "year" or "month" is only
@@ -309,7 +309,7 @@ object Period {
  * The period is modeled as a directed amount of time, meaning that individual parts of the period
  * may be negative.
  *
- * The months and years fields may be {@linkplain #normalized() normalized}. The normalization
+ * The months and years fields may be {@linkplain #normalized() normalized} . The normalization
  * assumes a 12 month year, so is not appropriate for all calendar systems.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
@@ -418,7 +418,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param years
    *   the years to represent, may be negative
    * @return
-   *   a { @code Period} based on this period with the requested years, not null
+   *   a {@code Period} based on this period with the requested years, not null
    */
   def withYears(years: Int): Period =
     if (years == this.years) this
@@ -438,7 +438,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param months
    *   the months to represent, may be negative
    * @return
-   *   a { @code Period} based on this period with the requested months, not null
+   *   a {@code Period} based on this period with the requested months, not null
    */
   def withMonths(months: Int): Period =
     if (months == this.months) this
@@ -455,7 +455,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param days
    *   the days to represent, may be negative
    * @return
-   *   a { @code Period} based on this period with the requested days, not null
+   *   a {@code Period} based on this period with the requested days, not null
    */
   def withDays(days: Int): Period =
     if (days == this.days) this
@@ -464,7 +464,7 @@ final class Period private (private val years: Int, private val months: Int, pri
   /**
    * Returns a copy of this period with the specified amount added.
    *
-   * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)}. This
+   * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)} . This
    * operates separately on the years, months and days.
    *
    * For example, "1 year, 6 months and 3 days" plus "2 years, 2 months and 2 days" returns "3
@@ -475,7 +475,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param amountToAdd
    *   the period to add, not null
    * @return
-   *   a { @code Period} based on this period with the requested period added, not null
+   *   a {@code Period} based on this period with the requested period added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -499,7 +499,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param yearsToAdd
    *   the years to add, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified years added, not null
+   *   a {@code Period} based on this period with the specified years added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -519,7 +519,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param monthsToAdd
    *   the months to add, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified months added, not null
+   *   a {@code Period} based on this period with the specified months added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -539,7 +539,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param daysToAdd
    *   the days to add, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified days added, not null
+   *   a {@code Period} based on this period with the specified days added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -550,7 +550,7 @@ final class Period private (private val years: Int, private val months: Int, pri
   /**
    * Returns a copy of this period with the specified amount subtracted.
    *
-   * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)}. This
+   * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)} . This
    * operates separately on the years, months and days.
    *
    * For example, "1 year, 6 months and 3 days" minus "2 years, 2 months and 2 days" returns "-1
@@ -561,7 +561,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param amountToSubtract
    *   the period to subtract, not null
    * @return
-   *   a { @code Period} based on this period with the requested period subtracted, not null
+   *   a {@code Period} based on this period with the requested period subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -585,7 +585,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param yearsToSubtract
    *   the years to subtract, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified years subtracted, not null
+   *   a {@code Period} based on this period with the specified years subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -605,7 +605,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param monthsToSubtract
    *   the years to subtract, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified months subtracted, not null
+   *   a {@code Period} based on this period with the specified months subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -625,7 +625,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param daysToSubtract
    *   the months to subtract, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified days subtracted, not null
+   *   a {@code Period} based on this period with the specified days subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -642,7 +642,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param scalar
    *   the scalar to multiply by, not null
    * @return
-   *   a { @code Period} based on this period with the amounts multiplied by the scalar, not null
+   *   a {@code Period} based on this period with the amounts multiplied by the scalar, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -658,7 +658,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * Returns a new instance with each amount in this period negated.
    *
    * @return
-   *   a { @code Period} based on this period with the amounts negated, not null
+   *   a {@code Period} based on this period with the amounts negated, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -680,7 +680,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code Period} based on this period with excess months normalized to years, not null
+   *   a {@code Period} based on this period with excess months normalized to years, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -817,7 +817,7 @@ final class Period private (private val years: Int, private val months: Int, pri
   override def hashCode: Int = years + Integer.rotateLeft(months, 8) + Integer.rotateLeft(days, 16)
 
   /**
-   * Outputs this period as a {@code String}, such as {@code P6Y3M1D}.
+   * Outputs this period as a {@code String} , such as {@code P6Y3M1D} .
    *
    * The output will be in the ISO-8601 period format. A zero period will be represented as zero
    * days, 'P0D'.
diff --git a/core/shared/src/main/scala/org/threeten/bp/Year.scala b/core/shared/src/main/scala/org/threeten/bp/Year.scala
index da7cb846c..0ff9b2280 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Year.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Year.scala
@@ -121,7 +121,7 @@ object Year {
   }
 
   /**
-   * Obtains an instance of {@code Year}.
+   * Obtains an instance of {@code Year} .
    *
    * This method accepts a year value from the proleptic ISO calendar system.
    *
@@ -129,7 +129,7 @@ object Year {
    * 1BC/BCE is represented by 0.<br> The year 2BC/BCE is represented by -1.<br>
    *
    * @param isoYear
-   *   the ISO proleptic year to represent, from { @code MIN_VALUE} to { @code MAX_VALUE}
+   *   the ISO proleptic year to represent, from {@code MIN_VALUE} to {@code MAX_VALUE}
    * @return
    *   the year, not null
    * @throws DateTimeException
@@ -144,21 +144,21 @@ object Year {
    * Obtains an instance of {@code Year} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Year}.
+   * converts the arbitrary temporal object to an instance of {@code Year} .
    *
    * The conversion extracts the {@link ChronoField#YEAR year} field. The extraction is only
    * permitted if the temporal object has an ISO chronology, or can be converted to a {@code
    * LocalDate}.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Year::from}.
+   * to be used in queries via method reference, {@code Year::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the year, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Year}
+   *   if unable to convert to a {@code Year}
    */
   def from(temporal: TemporalAccessor): Year = {
     var _temporal = temporal
@@ -180,7 +180,7 @@ object Year {
   }
 
   /**
-   * Obtains an instance of {@code Year} from a text string such as {@code 2007}.
+   * Obtains an instance of {@code Year} from a text string such as {@code 2007} .
    *
    * The string must represent a valid year. Years outside the range 0000 to 9999 must be prefixed
    * by the plus or minus symbol.
@@ -240,7 +240,7 @@ object Year {
 }
 
 /**
- * A year in the ISO-8601 calendar system, such as {@code 2007}.
+ * A year in the ISO-8601 calendar system, such as {@code 2007} .
  *
  * {@code Year} is an immutable date-time object that represents a year. Any field that can be
  * derived from a year can be obtained.
@@ -250,7 +250,7 @@ object Year {
  * such, historical years must be treated with caution.</b>
  *
  * This class does not store or represent a month, day, time or time-zone. For example, the value
- * "2007" can be stored in a {@code Year}.
+ * "2007" can be stored in a {@code Year} .
  *
  * Years represented by this class follow the ISO-8601 standard and use the proleptic numbering
  * system. Year 1 is preceded by year 0, then by year -1.
@@ -278,10 +278,10 @@ final class Year private (private val year: Int)
   /**
    * Gets the year value.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}.
+   * The year returned by this method is proleptic as per {@code get(YEAR)} .
    *
    * @return
-   *   the year, { @code MIN_VALUE} to { @code MAX_VALUE}
+   *   the year, {@code MIN_VALUE} to {@code MAX_VALUE}
    */
   def getValue: Int = year
 
@@ -297,7 +297,7 @@ final class Year private (private val year: Int)
    * The supported fields are: <ul> <li>{@code YEAR_OF_ERA} <li>{@code YEAR} <li>{@code ERA} </ul>
    * All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -327,9 +327,9 @@ final class Year private (private val year: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -348,7 +348,7 @@ final class Year private (private val year: Int)
       super.range(field)
 
   /**
-   * Gets the value of the specified field from this year as an {@code int}.
+   * Gets the value of the specified field from this year as an {@code int} .
    *
    * This queries this year for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
@@ -356,9 +356,9 @@ final class Year private (private val year: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this year. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -375,16 +375,16 @@ final class Year private (private val year: Int)
     range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this year as a {@code long}.
+   * Gets the value of the specified field from this year as a {@code long} .
    *
    * This queries this year for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this year. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -450,7 +450,7 @@ final class Year private (private val year: Int)
   /**
    * Returns an adjusted copy of this year.
    *
-   * This returns a new {@code Year}, based on this one, with the year adjusted. The adjustment
+   * This returns a new {@code Year} , based on this one, with the year adjusted. The adjustment
    * takes place using the specified adjuster strategy object. Read the documentation of the
    * adjuster to understand what adjustment will be made.
    *
@@ -463,7 +463,7 @@ final class Year private (private val year: Int)
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code Year} based on { @code this} with the adjustment made, not null
+   *   a {@code Year} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -475,23 +475,23 @@ final class Year private (private val year: Int)
   /**
    * Returns a copy of this year with the specified field set to a new value.
    *
-   * This returns a new {@code Year}, based on this one, with the value for the specified field
+   * This returns a new {@code Year} , based on this one, with the value for the specified field
    * changed. If it is not possible to set the value, because the field is not supported or for some
    * other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
    * fields behave as follows: <ul> <li>{@code YEAR_OF_ERA} - Returns a {@code Year} with the
    * specified year-of-era The era will be unchanged. <li>{@code YEAR} - Returns a {@code Year} with
-   * the specified year. This completely replaces the date and is equivalent to {@link #of(int)}.
+   * the specified year. This completely replaces the date and is equivalent to {@link #of(int)} .
    * <li>{@code ERA} - Returns a {@code Year} with the specified era. The year-of-era will be
    * unchanged. </ul>
    *
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -502,7 +502,7 @@ final class Year private (private val year: Int)
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code Year} based on { @code this} with the specified field set, not null
+   *   a {@code Year} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -528,14 +528,14 @@ final class Year private (private val year: Int)
    * This method returns a new year based on this year with the specified period added. The adder is
    * typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}.
+   * to {@link #plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code Year} based on this year with the addition made, not null
+   *   a {@code Year} based on this year with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -547,9 +547,9 @@ final class Year private (private val year: Int)
    * {@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   def plus(amountToAdd: Long, unit: TemporalUnit): Year =
     unit match {
@@ -574,7 +574,7 @@ final class Year private (private val year: Int)
    * @param yearsToAdd
    *   the years to add, may be negative
    * @return
-   *   a { @code Year} based on this year with the period added, not null
+   *   a {@code Year} based on this year with the period added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported year range
    */
@@ -590,14 +590,14 @@ final class Year private (private val year: Int)
    * This method returns a new year based on this year with the specified period subtracted. The
    * subtractor is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@link #minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code Year} based on this year with the subtraction made, not null
+   *   a {@code Year} based on this year with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -609,9 +609,9 @@ final class Year private (private val year: Int)
    * {@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): Year =
     if (amountToSubtract == Long.MinValue) plus(Long.MaxValue, unit).plus(1, unit)
@@ -625,7 +625,7 @@ final class Year private (private val year: Int)
    * @param yearsToSubtract
    *   the years to subtract, may be negative
    * @return
-   *   a { @code Year} based on this year with the period subtracted, not null
+   *   a {@code Year} based on this year with the period subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported year range
    */
@@ -704,7 +704,7 @@ final class Year private (private val year: Int)
    *
    * This calculates the period between two years in terms of a single unit. The start and end
    * points are {@code this} and the specified year. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code Year}. For
+   * before the start. The {@code Temporal} passed to this method must be a {@code Year} . For
    * example, the period in decades between two year can be calculated using {@code
    * startYear.until(endYear, DECADES)}.
    *
@@ -712,24 +712,24 @@ final class Year private (private val year: Int)
    * two years. For example, the period in decades between 2012 and 2031 will only be one decade as
    * it is one year short of two decades.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, YEARS); // this method dateTime.plus(YEARS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code YEARS},
-   * {@code DECADES}, {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code YEARS}
+   * , {@code DECADES} , {@code CENTURIES} , {@code MILLENNIA} and {@code ERAS} are supported. Other
    * {@code ChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end year, which is converted to a { @code Year}, not null
+   *   the end year, which is converted to a {@code Year} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -758,7 +758,7 @@ final class Year private (private val year: Int)
   }
 
   /**
-   * Combines this year with a day-of-year to create a {@code LocalDate}.
+   * Combines this year with a day-of-year to create a {@code LocalDate} .
    *
    * This returns a {@code LocalDate} formed from this year and the specified day-of-year.
    *
@@ -775,7 +775,7 @@ final class Year private (private val year: Int)
   def atDay(dayOfYear: Int): LocalDate = LocalDate.ofYearDay(year, dayOfYear)
 
   /**
-   * Combines this year with a month to create a {@code YearMonth}.
+   * Combines this year with a month to create a {@code YearMonth} .
    *
    * This returns a {@code YearMonth} formed from this year and the specified month. All possible
    * combinations of year and month are valid.
@@ -791,7 +791,7 @@ final class Year private (private val year: Int)
   def atMonth(month: Month): YearMonth = YearMonth.of(year, month)
 
   /**
-   * Combines this year with a month to create a {@code YearMonth}.
+   * Combines this year with a month to create a {@code YearMonth} .
    *
    * This returns a {@code YearMonth} formed from this year and the specified month. All possible
    * combinations of year and month are valid.
@@ -809,7 +809,7 @@ final class Year private (private val year: Int)
   def atMonth(month: Int): YearMonth = YearMonth.of(year, month)
 
   /**
-   * Combines this year with a month-day to create a {@code LocalDate}.
+   * Combines this year with a month-day to create a {@code LocalDate} .
    *
    * This returns a {@code LocalDate} formed from this year and the specified month-day.
    *
@@ -827,7 +827,7 @@ final class Year private (private val year: Int)
    * Compares this year to another year.
    *
    * The comparison is based on the value of the year. It is "consistent with equals", as defined by
-   * {@link Comparable}.
+   * {@link Comparable} .
    *
    * @param other
    *   the other year to compare to, not null
@@ -883,7 +883,7 @@ final class Year private (private val year: Int)
   override def hashCode: Int = year
 
   /**
-   * Outputs this year as a {@code String}.
+   * Outputs this year as a {@code String} .
    *
    * @return
    *   a string representation of this year, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala b/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala
index b26ae855c..ce5ca0d6f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala
@@ -63,14 +63,14 @@ import org.threeten.bp.temporal.UnsupportedTemporalTypeException
 import org.threeten.bp.temporal.ValueRange
 
 /**
- * A year-month in the ISO-8601 calendar system, such as {@code 2007-12}.
+ * A year-month in the ISO-8601 calendar system, such as {@code 2007-12} .
  *
  * {@code YearMonth} is an immutable date-time object that represents the combination of a year and
  * month. Any field that can be derived from a year and month, such as quarter-of-year, can be
  * obtained.
  *
  * This class does not store or represent a day, time or time-zone. For example, the value "October
- * 2007" can be stored in a {@code YearMonth}.
+ * 2007" can be stored in a {@code YearMonth} .
  *
  * The ISO-8601 calendar system is the modern civil calendar system used today in most of the world.
  * It is equivalent to the proleptic Gregorian calendar system, in which today's rules for leap
@@ -176,21 +176,21 @@ object YearMonth {
    * Obtains an instance of {@code YearMonth} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code YearMonth}.
+   * converts the arbitrary temporal object to an instance of {@code YearMonth} .
    *
    * The conversion extracts the {@link ChronoField#YEAR YEAR} and {@link ChronoField#MONTH_OF_YEAR
    * MONTH_OF_YEAR} fields. The extraction is only permitted if the temporal object has an ISO
-   * chronology, or can be converted to a {@code LocalDate}.
+   * chronology, or can be converted to a {@code LocalDate} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code YearMonth::from}.
+   * to be used in queries via method reference, {@code YearMonth::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the year-month, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code YearMonth}
+   *   if unable to convert to a {@code YearMonth}
    */
   def from(temporal: TemporalAccessor): YearMonth = {
     var _temporal = temporal
@@ -209,10 +209,10 @@ object YearMonth {
   }
 
   /**
-   * Obtains an instance of {@code YearMonth} from a text string such as {@code 2007-12}.
+   * Obtains an instance of {@code YearMonth} from a text string such as {@code 2007-12} .
    *
-   * The string must represent a valid year-month. The format must be {@code yyyy-MM}. Years outside
-   * the range 0000 to 9999 must be prefixed by the plus or minus symbol.
+   * The string must represent a valid year-month. The format must be {@code yyyy-MM} . Years
+   * outside the range 0000 to 9999 must be prefixed by the plus or minus symbol.
    *
    * @param text
    *   the text to parse such as "2007-12", not null
@@ -293,7 +293,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * YEAR_OF_ERA} <li>{@code YEAR} <li>{@code ERA} </ul> All other {@code ChronoField} instances
    * will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -323,9 +323,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -347,7 +347,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this year-month as an {@code int}.
+   * Gets the value of the specified field from this year-month as an {@code int} .
    *
    * This queries this year-month for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -356,10 +356,10 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this
    * year-month, except {@code EPOCH_MONTH} which is too large to fit in an {@code int} and throw a
-   * {@code DateTimeException}. All other {@code ChronoField} instances will throw a {@code
+   * {@code DateTimeException} . All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -376,7 +376,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
     range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this year-month as a {@code long}.
+   * Gets the value of the specified field from this year-month as a {@code long} .
    *
    * This queries this year-month for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -384,9 +384,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this
-   * year-month. All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * year-month. All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -418,7 +418,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    *
    * This method returns the primitive {@code int} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}.
+   * The year returned by this method is proleptic as per {@code get(YEAR)} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -429,7 +429,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Gets the month-of-year field from 1 to 12.
    *
    * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * clearer if the enum {@link Month} is used by calling {@link #getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -443,7 +443,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    *
    * This method returns the enum {@link Month} for the month. This avoids confusion as to what
    * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * provides the {@link Month#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -503,7 +503,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
   /**
    * Returns an adjusted copy of this year-month.
    *
-   * This returns a new {@code YearMonth}, based on this one, with the year-month adjusted. The
+   * This returns a new {@code YearMonth} , based on this one, with the year-month adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
@@ -520,7 +520,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code YearMonth} based on { @code this} with the adjustment made, not null
+   *   a {@code YearMonth} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -532,10 +532,10 @@ final class YearMonth private (private val year: Int, private val month: Int)
   /**
    * Returns a copy of this year-month with the specified field set to a new value.
    *
-   * This returns a new {@code YearMonth}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the year or month. If it is
-   * not possible to set the value, because the field is not supported or for some other reason, an
-   * exception is thrown.
+   * This returns a new {@code YearMonth} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the year or month. If it
+   * is not possible to set the value, because the field is not supported or for some other reason,
+   * an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
    * fields behave as follows: <ul> <li>{@code MONTH_OF_YEAR} - Returns a {@code YearMonth} with the
@@ -549,9 +549,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -562,7 +562,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code YearMonth} based on { @code this} with the specified field set, not null
+   *   a {@code YearMonth} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -598,7 +598,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param year
    *   the year to set in the returned year-month, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code YearMonth} based on this year-month with the requested year, not null
+   *   a {@code YearMonth} based on this year-month with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -615,7 +615,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param month
    *   the month-of-year to set in the returned year-month, from 1 (January) to 12 (December)
    * @return
-   *   a { @code YearMonth} based on this year-month with the requested month, not null
+   *   a {@code YearMonth} based on this year-month with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -630,14 +630,14 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * This method returns a new year-month based on this year-month with the specified period added.
    * The adder is typically {@link org.threeten.bp.Period Period} but may be any other type
    * implementing the {@link TemporalAmount} interface. The calculation is delegated to the
-   * specified adjuster, which typically calls back to {@link #plus(long, TemporalUnit)}.
+   * specified adjuster, which typically calls back to {@link #plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code YearMonth} based on this year-month with the addition made, not null
+   *   a {@code YearMonth} based on this year-month with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -649,9 +649,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * {@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   def plus(amountToAdd: Long, unit: TemporalUnit): YearMonth =
     if (unit.isInstanceOf[ChronoUnit])
@@ -675,7 +675,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param yearsToAdd
    *   the years to add, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the years added, not null
+   *   a {@code YearMonth} based on this year-month with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -695,7 +695,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param monthsToAdd
    *   the months to add, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the months added, not null
+   *   a {@code YearMonth} based on this year-month with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -715,14 +715,14 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * This method returns a new year-month based on this year-month with the specified period
    * subtracted. The subtractor is typically {@link org.threeten.bp.Period Period} but may be any
    * other type implementing the {@link TemporalAmount} interface. The calculation is delegated to
-   * the specified adjuster, which typically calls back to {@link #minus(long, TemporalUnit)}.
+   * the specified adjuster, which typically calls back to {@link #minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to aubtract, not null
    * @return
-   *   a { @code YearMonth} based on this year-month with the subtraction made, not null
+   *   a {@code YearMonth} based on this year-month with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -735,9 +735,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * {@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@inheritDoc}
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): YearMonth =
     if (amountToSubtract == Long.MinValue) plus(Long.MaxValue, unit).plus(1, unit)
@@ -751,7 +751,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param yearsToSubtract
    *   the years to subtract, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the years subtracted, not null
+   *   a {@code YearMonth} based on this year-month with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -767,7 +767,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param monthsToSubtract
    *   the months to subtract, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the months subtracted, not null
+   *   a {@code YearMonth} based on this year-month with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -847,7 +847,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    *
    * This calculates the period between two year-months in terms of a single unit. The start and end
    * points are {@code this} and the specified year-month. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code YearMonth}. For
+   * before the start. The {@code Temporal} passed to this method must be a {@code YearMonth} . For
    * example, the period in years between two year-months can be calculated using {@code
    * startYearMonth.until(endYearMonth, YEARS)}.
    *
@@ -855,7 +855,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * two year-months. For example, the period in decades between 2012-06 and 2032-05 will only be
    * one decade as it is one month short of two decades.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction:
    * {{{
@@ -863,18 +863,18 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * dateTime.plus(YEARS.between(start, end));     // use in plus/minus
    * }}}
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code MONTHS},
-   * {@code YEARS}, {@code DECADES}, {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code MONTHS}
+   * , {@code YEARS} , {@code DECADES} , {@code CENTURIES} , {@code MILLENNIA} and {@code ERAS} are
    * supported. Other {@code ChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end year-month, which is converted to a { @code YearMonth}, not null
+   *   the end year-month, which is converted to a {@code YearMonth} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -903,7 +903,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
   }
 
   /**
-   * Combines this year-month with a day-of-month to create a {@code LocalDate}.
+   * Combines this year-month with a day-of-month to create a {@code LocalDate} .
    *
    * This returns a {@code LocalDate} formed from this year-month and the specified day-of-month.
    *
@@ -941,7 +941,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Compares this year-month to another year-month.
    *
    * The comparison is based first on the value of the year, then on the value of the month. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@link Comparable} .
    *
    * @param other
    *   the other year-month to compare to, not null
@@ -1002,9 +1002,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
   override def hashCode: Int = year ^ (month << 27)
 
   /**
-   * Outputs this year-month as a {@code String}, such as {@code 2007-12}.
+   * Outputs this year-month as a {@code String} , such as {@code 2007-12} .
    *
-   * The output will be in the format {@code yyyy-MM}:
+   * The output will be in the format {@code yyyy-MM} :
    *
    * @return
    *   a string representation of this year-month, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala b/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala
index 4c24a006f..f7320871a 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala
@@ -50,7 +50,7 @@ object ZoneId {
   /**
    * A map of zone overrides to enable the short time-zone names to be used.
    *
-   * Use of short zone IDs has been deprecated in {@code java.util.TimeZone}. This map allows the
+   * Use of short zone IDs has been deprecated in {@code java.util.TimeZone} . This map allows the
    * IDs to continue to be used via the {@link #of(String, Map)} factory method.
    *
    * This map contains a mapping of the IDs that is in line with TZDB 2005r and later, where 'EST',
@@ -105,8 +105,8 @@ object ZoneId {
    * Gets the system default time-zone.
    *
    * This queries {@link TimeZone#getDefault()} to find the default time-zone and converts it to a
-   * {@code ZoneId}. If the system default time-zone is changed, then the result of this method will
-   * also change.
+   * {@code ZoneId} . If the system default time-zone is changed, then the result of this method
+   * will also change.
    *
    * @return
    *   the zone ID, not null
@@ -122,7 +122,7 @@ object ZoneId {
    *
    * This set includes the string form of all available region-based IDs. Offset-based zone IDs are
    * not included in the returned set. The ID can be passed to {@link #of(String)} to create a
-   * {@code ZoneId}.
+   * {@code ZoneId} .
    *
    * The set of zone IDs can increase over time, although in a typical application the set of IDs is
    * fixed. Each call to this method is thread-safe.
@@ -163,28 +163,28 @@ object ZoneId {
    * Obtains an instance of {@code ZoneId} from an ID ensuring that the ID is valid and available
    * for use.
    *
-   * This method parses the ID producing a {@code ZoneId} or {@code ZoneOffset}. A {@code
+   * This method parses the ID producing a {@code ZoneId} or {@code ZoneOffset} . A {@code
    * ZoneOffset} is returned if the ID is 'Z', or starts with '+' or '-'. The result will always be
    * a valid ID for which {@link ZoneRules} can be obtained.
    *
    * Parsing matches the zone ID step by step as follows. <ul> <li>If the zone ID equals 'Z', the
-   * result is {@code ZoneOffset.UTC}. <li>If the zone ID consists of a single letter, the zone ID
+   * result is {@code ZoneOffset.UTC} . <li>If the zone ID consists of a single letter, the zone ID
    * is invalid and {@code DateTimeException} is thrown. <li>If the zone ID starts with '+' or '-',
-   * the ID is parsed as a {@code ZoneOffset} using {@link ZoneOffset#of(String)}. <li>If the zone
+   * the ID is parsed as a {@code ZoneOffset} using {@link ZoneOffset#of(String)} . <li>If the zone
    * ID equals 'GMT', 'UTC' or 'UT' then the result is a {@code ZoneId} with the same ID and rules
-   * equivalent to {@code ZoneOffset.UTC}. <li>If the zone ID starts with 'UTC+', 'UTC-', 'GMT+',
+   * equivalent to {@code ZoneOffset.UTC} . <li>If the zone ID starts with 'UTC+', 'UTC-', 'GMT+',
    * 'GMT-', 'UT+' or 'UT-' then the ID is a prefixed offset-based ID. The ID is split in two, with
    * a two or three letter prefix and a suffix starting with the sign. The suffix is parsed as a
-   * {@link ZoneOffset#of(String) ZoneOffset}. The result will be a {@code ZoneId} with the
-   * specified UTC/GMT/UT prefix and the normalized offset ID as per {@link ZoneOffset#getId()}. The
-   * rules of the returned {@code ZoneId} will be equivalent to the parsed {@code ZoneOffset}.
+   * {@link ZoneOffset#of(String) ZoneOffset} . The result will be a {@code ZoneId} with the
+   * specified UTC/GMT/UT prefix and the normalized offset ID as per {@link ZoneOffset#getId()} .
+   * The rules of the returned {@code ZoneId} will be equivalent to the parsed {@code ZoneOffset} .
    * <li>All other IDs are parsed as region-based zone IDs. Region IDs must match the regular
    * expression <code>[A-Za-z][A-Za-z0-9~/._+-]+</code> otherwise a {@code DateTimeException} is
    * thrown. If the zone ID is not in the configured set of IDs, {@code ZoneRulesException} is
    * thrown. The detailed format of the region ID depends on the group supplying the data. The
    * default set of data is supplied by the IANA Time Zone Database (TZDB). This has region IDs of
    * the form '{area}/{city}', such as 'Europe/Paris' or 'America/New_York'. This is compatible with
-   * most IDs from {@link java.util.TimeZone}. </ul>
+   * most IDs from {@link java.util.TimeZone} . </ul>
    *
    * @param zoneId
    *   the time-zone ID, not null
@@ -256,20 +256,20 @@ object ZoneId {
    * Obtains an instance of {@code ZoneId} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code ZoneId}.
+   * converts the arbitrary temporal object to an instance of {@code ZoneId} .
    *
    * The conversion will try to obtain the zone in a way that favours region-based zones over
-   * offset-based zones using {@link TemporalQueries#zone()}.
+   * offset-based zones using {@link TemporalQueries#zone()} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code ZoneId::from}.
+   * to be used in queries via method reference, {@code ZoneId::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the zone ID, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ZoneId}
+   *   if unable to convert to a {@code ZoneId}
    */
   def from(temporal: TemporalAccessor): ZoneId = {
     val obj: ZoneId = temporal.query(TemporalQueries.zone)
@@ -282,17 +282,17 @@ object ZoneId {
 }
 
 /**
- * A time-zone ID, such as {@code Europe/Paris}.
+ * A time-zone ID, such as {@code Europe/Paris} .
  *
  * A {@code ZoneId} is used to identify the rules used to convert between an {@link Instant} and a
- * {@link LocalDateTime}. There are two distinct types of ID: <ul> <li>Fixed offsets - a fully
+ * {@link LocalDateTime} . There are two distinct types of ID: <ul> <li>Fixed offsets - a fully
  * resolved offset from UTC/Greenwich, that uses the same offset for all local date-times
  * <li>Geographical regions - an area where a specific set of rules for finding the offset from
- * UTC/Greenwich apply </ul> Most fixed offsets are represented by {@link ZoneOffset}. Calling
+ * UTC/Greenwich apply </ul> Most fixed offsets are represented by {@link ZoneOffset} . Calling
  * {@link #normalized()} on any {@code ZoneId} will ensure that a fixed offset ID will be
- * represented as a {@code ZoneOffset}.
+ * represented as a {@code ZoneOffset} .
  *
- * The actual rules, describing when and how the offset changes, are defined by {@link ZoneRules}.
+ * The actual rules, describing when and how the offset changes, are defined by {@link ZoneRules} .
  * This class is simply an ID used to obtain the underlying rules. This approach is taken because
  * rules are defined by governments and change frequently, whereas the ID is stable.
  *
@@ -302,7 +302,7 @@ object ZoneId {
  *
  * <h3>Time-zone IDs</h3> The ID is unique within the system. There are three types of ID.
  *
- * The simplest type of ID is that from {@code ZoneOffset}. This consists of 'Z' and IDs starting
+ * The simplest type of ID is that from {@code ZoneOffset} . This consists of 'Z' and IDs starting
  * with '+' or '-'.
  *
  * The next type of ID are offset-style IDs with some form of prefix, such as 'GMT+2' or
@@ -312,8 +312,8 @@ object ZoneId {
  *
  * The third type of ID are region-based IDs. A region-based ID must be of two or more characters,
  * and not start with 'UTC', 'GMT', 'UT' '+' or '-'. Region-based IDs are defined by configuration,
- * see {@link ZoneRulesProvider}. The configuration focuses on providing the lookup from the ID to
- * the underlying {@code ZoneRules}.
+ * see {@link ZoneRulesProvider} . The configuration focuses on providing the lookup from the ID to
+ * the underlying {@code ZoneRules} .
  *
  * Time-zone rules are defined by governments and change frequently. There are a number of
  * organizations, known here as groups, that monitor time-zone changes and collate them. The default
@@ -336,10 +336,10 @@ object ZoneId {
  * A {@code ZoneId} can be deserialized in a Java Runtime where the ID is unknown. For example, if a
  * server-side Java Runtime has been updated with a new zone ID, but the client-side Java Runtime
  * has not been updated. In this case, the {@code ZoneId} object will exist, and can be queried
- * using {@code getId}, {@code equals}, {@code hashCode}, {@code toString}, {@code getDisplayName}
- * and {@code normalized}. However, any call to {@code getRules} will fail with {@code
- * ZoneRulesException}. This approach is designed to allow a {@link ZonedDateTime} to be loaded and
- * queried, but not modified, on a Java Runtime with incomplete time-zone information.
+ * using {@code getId} , {@code equals} , {@code hashCode} , {@code toString} ,
+ * {@code getDisplayName} and {@code normalized} . However, any call to {@code getRules} will fail
+ * with {@code ZoneRulesException}. This approach is designed to allow a {@link ZonedDateTime} to be
+ * loaded and queried, but not modified, on a Java Runtime with incomplete time-zone information.
  *
  * <h3>Specification for implementors</h3> This abstract class has two implementations, both of
  * which are immutable and thread-safe. One implementation models region-based IDs, the other is
@@ -372,9 +372,9 @@ abstract class ZoneId private[bp] () extends Serializable {
    *
    * A time-zone can be invalid if it is deserialized in a Java Runtime which does not have the same
    * rules loaded as the Java Runtime that stored it. In this case, calling this method will throw a
-   * {@code ZoneRulesException}.
+   * {@code ZoneRulesException} .
    *
-   * The rules are supplied by {@link ZoneRulesProvider}. An advanced provider may support dynamic
+   * The rules are supplied by {@link ZoneRulesProvider} . An advanced provider may support dynamic
    * updates to the rules without restarting the Java Runtime. If so, then the result of this method
    * may change over time. Each individual call will be still remain thread-safe.
    *
@@ -407,7 +407,7 @@ abstract class ZoneId private[bp] () extends Serializable {
       .appendZoneText(style)
       .toFormatter(locale)
       .format(new TemporalAccessor() {
-        def isSupported(field: TemporalField): Boolean = false
+        def isSupported(field: TemporalField): Boolean    = false
         def getLong(field: TemporalField): Long           =
           throw new UnsupportedTemporalTypeException(s"Unsupported field: $field")
         override def query[R](query: TemporalQuery[R]): R =
@@ -467,7 +467,7 @@ abstract class ZoneId private[bp] () extends Serializable {
   override def hashCode: Int = getId.hashCode
 
   /**
-   * Outputs this zone as a {@code String}, using the ID.
+   * Outputs this zone as a {@code String} , using the ID.
    *
    * @return
    *   a string representation of this time-zone ID, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala b/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala
index b82705208..0d356c456 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala
@@ -82,7 +82,7 @@ object ZoneOffset {
    * Obtains an instance of {@code ZoneOffset} using the ID.
    *
    * This method parses the string ID of a {@code ZoneOffset} to return an instance. The parsing
-   * accepts all the formats generated by {@link #getId()}, plus some additional formats: <ul>
+   * accepts all the formats generated by {@link #getId()} , plus some additional formats: <ul>
    * <li>{@code Z} - for UTC <li>{@code +h} <li>{@code +hh} <li>{@code +hh:mm} <li>{@code -hh:mm}
    * <li>{@code +hhmm} <li>{@code -hhmm} <li>{@code +hh:mm:ss} <li>{@code -hh:mm:ss} <li>{@code
    * +hhmmss} <li>{@code -hhmmss} </ul><p> Note that &plusmn; means either the plus or minus symbol.
@@ -234,20 +234,20 @@ object ZoneOffset {
    * Obtains an instance of {@code ZoneOffset} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code ZoneOffset}.
+   * converts the arbitrary temporal object to an instance of {@code ZoneOffset} .
    *
    * The conversion uses the {@link TemporalQueries#offset()} query, which relies on extracting the
    * {@link ChronoField#OFFSET_SECONDS OFFSET_SECONDS} field.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code ZoneOffset::from}.
+   * to be used in queries via method reference, {@code ZoneOffset::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the zone-offset, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code ZoneOffset}
+   *   if unable to convert to an {@code ZoneOffset}
    */
   def from(temporal: TemporalAccessor): ZoneOffset = {
     val offset: ZoneOffset = temporal.query(TemporalQueries.offset)
@@ -322,7 +322,7 @@ object ZoneOffset {
   /**
    * Obtains an instance of {@code ZoneOffset} specifying the total offset in seconds
    *
-   * The offset must be in the range {@code -18:00} to {@code +18:00}, which corresponds to -64800
+   * The offset must be in the range {@code -18:00} to {@code +18:00} , which corresponds to -64800
    * to +64800.
    *
    * @param totalSeconds
@@ -371,7 +371,7 @@ object ZoneOffset {
 }
 
 /**
- * A time-zone offset from Greenwich/UTC, such as {@code +02:00}.
+ * A time-zone offset from Greenwich/UTC, such as {@code +02:00} .
  *
  * A time-zone offset is the period of time that a time-zone differs from Greenwich/UTC. This is
  * usually a fixed number of hours and minutes.
@@ -392,7 +392,7 @@ object ZoneOffset {
  * class may be used with other calendar systems providing the definition of the time fields matches
  * those of the ISO calendar system.
  *
- * Instances of {@code ZoneOffset} must be compared using {@link #equals}. Implementations may
+ * Instances of {@code ZoneOffset} must be compared using {@link #equals} . Implementations may
  * choose to cache certain common offsets, however applications must not rely on such caching.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
@@ -457,7 +457,7 @@ final class ZoneOffset private (private val totalSeconds: Int)
    * If the field is a {@link ChronoField} then the query is implemented here. The {@code
    * OFFSET_SECONDS} field returns true. All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -479,9 +479,9 @@ final class ZoneOffset private (private val totalSeconds: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -501,7 +501,7 @@ final class ZoneOffset private (private val totalSeconds: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this offset as an {@code int}.
+   * Gets the value of the specified field from this offset as an {@code int} .
    *
    * This queries this offset for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
@@ -509,9 +509,9 @@ final class ZoneOffset private (private val totalSeconds: Int)
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@code
    * OFFSET_SECONDS} field returns the value of the offset. All other {@code ChronoField} instances
-   * will throw a {@code DateTimeException}.
+   * will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -533,16 +533,16 @@ final class ZoneOffset private (private val totalSeconds: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this offset as a {@code long}.
+   * Gets the value of the specified field from this offset as a {@code long} .
    *
    * This queries this offset for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@code
    * OFFSET_SECONDS} field returns the value of the offset. All other {@code ChronoField} instances
-   * will throw a {@code DateTimeException}.
+   * will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -628,16 +628,16 @@ final class ZoneOffset private (private val totalSeconds: Int)
    *
    * The offsets are compared in the order that they occur for the same time of day around the
    * world. Thus, an offset of {@code +10:00} comes before an offset of {@code +09:00} and so on
-   * down to {@code -18:00}.
+   * down to {@code -18:00} .
    *
-   * The comparison is "consistent with equals", as defined by {@link Comparable}.
+   * The comparison is "consistent with equals", as defined by {@link Comparable} .
    *
    * @param other
    *   the other date to compare to, not null
    * @return
    *   the comparator value, negative if less, postive if greater
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@code other} is null
    */
   def compare(other: ZoneOffset): Int = other.totalSeconds - totalSeconds
 
@@ -669,7 +669,7 @@ final class ZoneOffset private (private val totalSeconds: Int)
   override def hashCode: Int = totalSeconds
 
   /**
-   * Outputs this offset as a {@code String}, using the normalized ID.
+   * Outputs this offset as a {@code String} , using the normalized ID.
    *
    * @return
    *   a string representation of this offset, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala b/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala
index b5a6544c8..3536c6ff3 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala
@@ -85,7 +85,7 @@ private object ZoneRegion {
  * (TZDB), which defines regions such as 'Europe/Paris' and 'Asia/Tokyo'.
  *
  * The region identifier, modeled by this class, is distinct from the underlying rules, modeled by
- * {@link ZoneRules}. The rules are defined by governments and change frequently. By contrast, the
+ * {@link ZoneRules} . The rules are defined by governments and change frequently. By contrast, the
  * region identifier is well-defined and long-lived. This separation also allows rules to be shared
  * between regions if appropriate.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala
index 60cfe322c..04691e931 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala
@@ -93,7 +93,7 @@ object ZonedDateTime {
    * be set based on the time-zone in the clock.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -287,7 +287,7 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from an {@code Instant}.
+   * Obtains an instance of {@code ZonedDateTime} from an {@code Instant} .
    *
    * This creates a zoned date-time with the same instant as that specified. Calling {@link
    * #toInstant()} will return an instant equal to the one used here.
@@ -315,14 +315,14 @@ object ZonedDateTime {
    * date-time and offset.
    *
    * This creates a zoned date-time by {@link LocalDateTime#toInstant(ZoneOffset) combining} the
-   * {@code LocalDateTime} and {@code ZoneOffset}. This combination uniquely specifies an instant
+   * {@code LocalDateTime} and {@code ZoneOffset} . This combination uniquely specifies an instant
    * without ambiguity.
    *
    * Converting an instant to a zoned date-time is simple as there is only one valid offset for each
    * instant. If the valid offset is different to the offset specified, the the date-time and offset
    * of the zoned date-time will differ from those specified.
    *
-   * If the {@code ZoneId} to be used is a {@code ZoneOffset}, this method is equivalent to {@link
+   * If the {@code ZoneId} to be used is a {@code ZoneOffset} , this method is equivalent to {@link
    * #of(LocalDateTime, ZoneId)}.
    *
    * @param localDateTime
@@ -401,21 +401,21 @@ object ZonedDateTime {
    * Obtains an instance of {@code ZonedDateTime} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code ZonedDateTime}.
+   * converts the arbitrary temporal object to an instance of {@code ZonedDateTime} .
    *
-   * The conversion will first obtain a {@code ZoneId}. It will then try to obtain an instant. If
+   * The conversion will first obtain a {@code ZoneId} . It will then try to obtain an instant. If
    * that fails it will try to obtain a local date-time. The zoned date time will either be a
    * combination of {@code ZoneId} and instant, or {@code ZoneId} and local date-time.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code ZonedDateTime::from}.
+   * to be used in queries via method reference, {@code ZonedDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the zoned date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code ZonedDateTime}
+   *   if unable to convert to an {@code ZonedDateTime}
    */
   def from(temporal: TemporalAccessor): ZonedDateTime =
     temporal match {
@@ -494,11 +494,11 @@ object ZonedDateTime {
  * ZonedDateTime}.
  *
  * This class handles conversion from the local time-line of {@code LocalDateTime} to the instant
- * time-line of {@code Instant}. The difference between the two time-lines is the offset from
- * UTC/Greenwich, represented by a {@code ZoneOffset}.
+ * time-line of {@code Instant} . The difference between the two time-lines is the offset from
+ * UTC/Greenwich, represented by a {@code ZoneOffset} .
  *
  * Converting between the two time-lines involves calculating the offset using the {@link ZoneRules
- * rules} accessed from the {@code ZoneId}. Obtaining the offset for an instant is simple, as there
+ * rules} accessed from the {@code ZoneId} . Obtaining the offset for an instant is simple, as there
  * is exactly one valid offset for each instant. By contrast, obtaining the offset for a local
  * date-time is not straightforward. There are three cases: <ul> <li>Normal, with one valid offset.
  * For the vast majority of the year, the normal case applies, where there is a single valid offset
@@ -522,10 +522,10 @@ object ZonedDateTime {
  * #withLaterOffsetAtOverlap()}, help manage the case of an overlap.
  *
  * <h3>Specification for implementors</h3> A {@code ZonedDateTime} holds state equivalent to three
- * separate objects, a {@code LocalDateTime}, a {@code ZoneId} and the resolved {@code ZoneOffset}.
- * The offset and local date-time are used to define an instant when necessary. The zone ID is used
- * to obtain the rules for how and when the offset changes. The offset cannot be freely set, as the
- * zone controls which offsets are valid.
+ * separate objects, a {@code LocalDateTime} , a {@code ZoneId} and the resolved {@code ZoneOffset}
+ * . The offset and local date-time are used to define an instant when necessary. The zone ID is
+ * used to obtain the rules for how and when the offset changes. The offset cannot be freely set, as
+ * the zone controls which offsets are valid.
  *
  * This class is immutable and thread-safe.
  *
@@ -602,7 +602,7 @@ final class ZonedDateTime(
    * <li>{@code YEAR} <li>{@code ERA} <li>{@code INSTANT_SECONDS} <li>{@code OFFSET_SECONDS} </ul>
    * All other {@code ChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the field is supported is determined by the field.
    *
@@ -635,9 +635,9 @@ final class ZonedDateTime(
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
@@ -658,7 +658,7 @@ final class ZonedDateTime(
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this date-time as an {@code int}.
+   * Gets the value of the specified field from this date-time as an {@code int} .
    *
    * This queries this date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
@@ -666,12 +666,12 @@ final class ZonedDateTime(
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY}, {@code EPOCH_DAY}, {@code EPOCH_MONTH} and
+   * except {@code NANO_OF_DAY} , {@code MICRO_OF_DAY} , {@code EPOCH_DAY} , {@code EPOCH_MONTH} and
    * {@code INSTANT_SECONDS} which are too large to fit in an {@code int} and throw a {@code
    * DateTimeException}. All other {@code ChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -697,7 +697,7 @@ final class ZonedDateTime(
     }
 
   /**
-   * Gets the value of the specified field from this date-time as a {@code long}.
+   * Gets the value of the specified field from this date-time as a {@code long} .
    *
    * This queries this date-time for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
@@ -705,9 +705,9 @@ final class ZonedDateTime(
    *
    * If the field is a {@link ChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@code ChronoField} instances will throw a {@code DateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
@@ -756,7 +756,7 @@ final class ZonedDateTime(
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the earlier offset, not null
+   *   a {@code ZonedDateTime} based on this date-time with the earlier offset, not null
    */
   def withEarlierOffsetAtOverlap: ZonedDateTime = {
     val trans: ZoneOffsetTransition = getZone.getRules.getTransition(dateTime)
@@ -782,7 +782,7 @@ final class ZonedDateTime(
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the later offset, not null
+   *   a {@code ZonedDateTime} based on this date-time with the later offset, not null
    */
   def withLaterOffsetAtOverlap: ZonedDateTime = {
     val trans: ZoneOffsetTransition = getZone.getRules.getTransition(toLocalDateTime)
@@ -802,9 +802,9 @@ final class ZonedDateTime(
    * This returns the zone ID. This identifies the time-zone {@link ZoneRules rules} that determine
    * when and how the offset from UTC/Greenwich changes.
    *
-   * The zone ID may be same as the {@link #getOffset() offset}. If this is true, then any future
+   * The zone ID may be same as the {@link #getOffset() offset} . If this is true, then any future
    * calculations, such as addition or subtraction, have no complex edge cases due to time-zone
-   * rules. See also {@link #withFixedOffsetZone()}.
+   * rules. See also {@link #withFixedOffsetZone()} .
    *
    * @return
    *   the time-zone, not null
@@ -819,14 +819,14 @@ final class ZonedDateTime(
    * changed if it is invalid for the new zone, determined using the same approach as {@link
    * #ofLocal(LocalDateTime, ZoneId, ZoneOffset)}.
    *
-   * To change the zone and adjust the local date-time, use {@link #withZoneSameInstant(ZoneId)}.
+   * To change the zone and adjust the local date-time, use {@link #withZoneSameInstant(ZoneId)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param zone
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested zone, not null
    */
   def withZoneSameLocal(zone: ZoneId): ZonedDateTime = {
     Objects.requireNonNull(zone, "zone")
@@ -842,12 +842,12 @@ final class ZonedDateTime(
    * This method is based on retaining the same instant, thus gaps and overlaps in the local
    * time-line have no effect on the result.
    *
-   * To change the offset while keeping the local time, use {@link #withZoneSameLocal(ZoneId)}.
+   * To change the offset while keeping the local time, use {@link #withZoneSameLocal(ZoneId)} .
    *
    * @param zone
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested zone, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -860,18 +860,18 @@ final class ZonedDateTime(
   /**
    * Returns a copy of this date-time with the zone ID set to the offset.
    *
-   * This returns a zoned date-time where the zone ID is the same as {@link #getOffset()}. The local
-   * date-time, offset and instant of the result will be the same as in this date-time.
+   * This returns a zoned date-time where the zone ID is the same as {@link #getOffset()} . The
+   * local date-time, offset and instant of the result will be the same as in this date-time.
    *
    * Setting the date-time to a fixed single offset means that any future calculations, such as
    * addition or subtraction, have no complex edge cases due to time-zone rules. This might also be
    * useful when sending a zoned date-time across a network, as most protocols, such as ISO-8601,
    * only handle offsets, and not region-based zone IDs.
    *
-   * This is equivalent to {@code ZonedDateTime.of(zdt.getDateTime(), zdt.getOffset())}.
+   * This is equivalent to {@code ZonedDateTime.of(zdt.getDateTime(), zdt.getOffset())} .
    *
    * @return
-   *   a { @code ZonedDateTime} with the zone ID set to the offset, not null
+   *   a {@code ZonedDateTime} with the zone ID set to the offset, not null
    */
   def withFixedOffsetZone: ZonedDateTime =
     if (this.zone == offset) this
@@ -882,8 +882,8 @@ final class ZonedDateTime(
    *
    * This method returns the primitive {@code int} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@code get(YEAR)} . To obtain the
+   * year-of-era, use {@code get(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -894,7 +894,7 @@ final class ZonedDateTime(
    * Gets the month-of-year field from 1 to 12.
    *
    * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * clearer if the enum {@link Month} is used by calling {@link #getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -908,7 +908,7 @@ final class ZonedDateTime(
    *
    * This method returns the enum {@link Month} for the month. This avoids confusion as to what
    * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * provides the {@link Month#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -938,13 +938,13 @@ final class ZonedDateTime(
   def getDayOfYear: Int = dateTime.getDayOfYear
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@code DayOfWeek} .
    *
    * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
    * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * enum provides the {@link DayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@code DayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -987,15 +987,15 @@ final class ZonedDateTime(
   /**
    * Returns an adjusted copy of this date-time.
    *
-   * This returns a new {@code ZonedDateTime}, based on this one, with the date-time adjusted. The
+   * This returns a new {@code ZonedDateTime} , based on this one, with the date-time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@link TemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay}. The adjuster is
+   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay} . The adjuster is
    * responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -1003,13 +1003,13 @@ final class ZonedDateTime(
    *
    * result = zonedDateTime.with(JULY).with(lastDayOfMonth()); </pre>
    *
-   * The classes {@link LocalDate} and {@link LocalTime} implement {@code TemporalAdjuster}, thus
+   * The classes {@link LocalDate} and {@link LocalTime} implement {@code TemporalAdjuster} , thus
    * this method can be used to change the date, time or offset: <pre> result =
    * zonedDateTime.with(date); result = zonedDateTime.with(time); </pre>
    *
    * {@link ZoneOffset} also implements {@code TemporalAdjuster} however it is less likely that
    * setting the offset will have the effect you expect. When an offset is passed in, the local
-   * date-time is combined with the new offset to form an {@code Instant}. The instant and original
+   * date-time is combined with the new offset to form an {@code Instant} . The instant and original
    * zone are then used to create the result. This algorithm means that it is quite likely that the
    * output has a different offset to the specified offset. It will however work correctly when
    * passing in the offset applicable for the instant of the zoned date-time, and will work
@@ -1025,7 +1025,7 @@ final class ZonedDateTime(
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code ZonedDateTime} based on { @code this} with the adjustment made, not null
+   *   a {@code ZonedDateTime} based on {@code this} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -1044,8 +1044,8 @@ final class ZonedDateTime(
   /**
    * Returns a copy of this date-time with the specified field set to a new value.
    *
-   * This returns a {@code ZonedDateTime}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the year, month or
+   * This returns a {@code ZonedDateTime} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
    *
@@ -1069,15 +1069,16 @@ final class ZonedDateTime(
    * value is outside the valid range then a {@code DateTimeException} will be thrown.
    *
    * The other {@link #isSupported(TemporalField) supported fields} will behave as per the matching
-   * method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime}. The zone is not part
-   * of the calculation and will be unchanged. When converting back to {@code ZonedDateTime}, if the
-   * local date-time is in an overlap, then the offset will be retained if possible, otherwise the
-   * earlier offset will be used. If in a gap, the local date-time will be adjusted forward by the
-   * length of the gap.
+   * method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime} . The zone is not part
+   * of the calculation and will be unchanged. When converting back to {@code ZonedDateTime} , if
+   * the local date-time is in an overlap, then the offset will be retained if possible, otherwise
+   * the earlier offset will be used. If in a gap, the local date-time will be adjusted forward by
+   * the length of the gap.
    *
-   * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
+   * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}
+   * .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
@@ -1088,7 +1089,7 @@ final class ZonedDateTime(
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code ZonedDateTime} based on { @code this} with the specified field set, not null
+   *   a {@code ZonedDateTime} based on {@code this} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws UnsupportedTemporalTypeException
@@ -1113,10 +1114,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the year value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withYear(int) changing the year} of
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1125,7 +1126,7 @@ final class ZonedDateTime(
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested year, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -1135,10 +1136,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the month-of-year value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withMonth(int) changing the month}
-   * of the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * of the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1147,7 +1148,7 @@ final class ZonedDateTime(
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested month, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -1157,10 +1158,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the day-of-month value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withDayOfMonth(int) changing the
-   * day-of-month} of the local date-time. This is then converted back to a {@code ZonedDateTime},
+   * day-of-month} of the local date-time. This is then converted back to a {@code ZonedDateTime} ,
    * using the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1169,7 +1170,7 @@ final class ZonedDateTime(
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested day, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -1182,10 +1183,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the day-of-year altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withDayOfYear(int) changing the
-   * day-of-year} of the local date-time. This is then converted back to a {@code ZonedDateTime},
+   * day-of-year} of the local date-time. This is then converted back to a {@code ZonedDateTime} ,
    * using the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1194,7 +1195,7 @@ final class ZonedDateTime(
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   a { @code ZonedDateTime} based on this date with the requested day, not null
+   *   a {@code ZonedDateTime} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -1206,10 +1207,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the hour-of-day value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withHour(int) changing the time} of
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1218,7 +1219,7 @@ final class ZonedDateTime(
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested hour, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -1228,10 +1229,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the minute-of-hour value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withMinute(int) changing the time}
-   * of the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * of the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1240,7 +1241,7 @@ final class ZonedDateTime(
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested minute, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -1250,10 +1251,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the second-of-minute value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withSecond(int) changing the time}
-   * of the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * of the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1262,7 +1263,7 @@ final class ZonedDateTime(
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested second, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -1272,10 +1273,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the nano-of-second value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withNano(int) changing the time} of
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1284,7 +1285,7 @@ final class ZonedDateTime(
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested nanosecond, not null
+   *   a {@code ZonedDateTime} based on this date-time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nano value is invalid
    */
@@ -1299,13 +1300,13 @@ final class ZonedDateTime(
    *
    * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This operates on the local time-line, {@link LocalDateTime#truncatedTo(TemporalUnit)
    * truncating} the underlying local date-time. This is then converted back to a {@code
    * ZonedDateTime}, using the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1314,7 +1315,7 @@ final class ZonedDateTime(
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the time truncated, not null
+   *   a {@code ZonedDateTime} based on this date-time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -1326,14 +1327,14 @@ final class ZonedDateTime(
    * This method returns a new date-time based on this time with the specified period added. The
    * amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #plus(long, TemporalUnit)}.
+   * typically calls back to {@link #plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the addition made, not null
+   *   a {@code ZonedDateTime} based on this date-time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -1367,7 +1368,7 @@ final class ZonedDateTime(
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the specified period added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1382,10 +1383,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in years added.
    *
    * This operates on the local time-line, {@link LocalDateTime#plusYears(long) adding years} to the
-   * local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID to
+   * local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID to
    * obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1394,7 +1395,7 @@ final class ZonedDateTime(
    * @param years
    *   the years to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the years added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1404,10 +1405,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in months added.
    *
    * This operates on the local time-line, {@link LocalDateTime#plusMonths(long) adding months} to
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1416,7 +1417,7 @@ final class ZonedDateTime(
    * @param months
    *   the months to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the months added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1426,10 +1427,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in weeks added.
    *
    * This operates on the local time-line, {@link LocalDateTime#plusWeeks(long) adding weeks} to the
-   * local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID to
+   * local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID to
    * obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1438,7 +1439,7 @@ final class ZonedDateTime(
    * @param weeks
    *   the weeks to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the weeks added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1448,10 +1449,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in days added.
    *
    * This operates on the local time-line, {@link LocalDateTime#plusDays(long) adding days} to the
-   * local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID to
+   * local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID to
    * obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1460,7 +1461,7 @@ final class ZonedDateTime(
    * @param days
    *   the days to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the days added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1485,7 +1486,7 @@ final class ZonedDateTime(
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the hours added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the hours added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1503,7 +1504,7 @@ final class ZonedDateTime(
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the minutes added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the minutes added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1521,7 +1522,7 @@ final class ZonedDateTime(
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the seconds added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1539,7 +1540,7 @@ final class ZonedDateTime(
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the nanoseconds added, not null
+   *   a {@code ZonedDateTime} based on this date-time with the nanoseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1551,14 +1552,14 @@ final class ZonedDateTime(
    * This method returns a new date-time based on this time with the specified period subtracted.
    * The amount is typically {@link Period} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@link #minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the subtraction made, not null
+   *   a {@code ZonedDateTime} based on this date-time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1592,7 +1593,7 @@ final class ZonedDateTime(
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the specified period subtracted, not
+   *   a {@code ZonedDateTime} based on this date-time with the specified period subtracted, not
    *   null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
@@ -1605,10 +1606,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in years subtracted.
    *
    * This operates on the local time-line, {@link LocalDateTime#minusYears(long) subtracting years}
-   * to the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * to the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1617,7 +1618,7 @@ final class ZonedDateTime(
    * @param years
    *   the years to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the years subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1629,10 +1630,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in months subtracted.
    *
    * This operates on the local time-line, {@link LocalDateTime#minusMonths(long) subtracting
-   * months} to the local date-time. This is then converted back to a {@code ZonedDateTime}, using
+   * months} to the local date-time. This is then converted back to a {@code ZonedDateTime} , using
    * the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1641,7 +1642,7 @@ final class ZonedDateTime(
    * @param months
    *   the months to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the months subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1653,10 +1654,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in weeks subtracted.
    *
    * This operates on the local time-line, {@link LocalDateTime#minusWeeks(long) subtracting weeks}
-   * to the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * to the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1665,7 +1666,7 @@ final class ZonedDateTime(
    * @param weeks
    *   the weeks to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the weeks subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1677,10 +1678,10 @@ final class ZonedDateTime(
    * Returns a copy of this {@code ZonedDateTime} with the specified period in days subtracted.
    *
    * This operates on the local time-line, {@link LocalDateTime#minusDays(long) subtracting days} to
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * the local date-time. This is then converted back to a {@code ZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@code ZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1689,7 +1690,7 @@ final class ZonedDateTime(
    * @param days
    *   the days to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the days subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1716,7 +1717,7 @@ final class ZonedDateTime(
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the hours subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the hours subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1736,7 +1737,7 @@ final class ZonedDateTime(
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the minutes subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the minutes subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1756,7 +1757,7 @@ final class ZonedDateTime(
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the seconds subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1777,7 +1778,7 @@ final class ZonedDateTime(
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the nanoseconds subtracted, not null
+   *   a {@code ZonedDateTime} based on this date-time with the nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1818,9 +1819,9 @@ final class ZonedDateTime(
    * This calculates the period between two date-times in terms of a single unit. The start and end
    * points are {@code this} and the specified date-time. The result will be negative if the end is
    * before the start. For example, the period in days between two date-times can be calculated
-   * using {@code startDateTime.until(endDateTime, DAYS)}.
+   * using {@code startDateTime.until(endDateTime, DAYS)} .
    *
-   * The {@code Temporal} passed to this method must be a {@code ZonedDateTime}. If the time-zone
+   * The {@code Temporal} passed to this method must be a {@code ZonedDateTime} . If the time-zone
    * differs between the two zoned date-times, the specified end date-time is normalized to have the
    * same zone as this date-time.
    *
@@ -1828,17 +1829,17 @@ final class ZonedDateTime(
    * two date-times. For example, the period in months between 2012-06-15T00:00Z and
    * 2012-08-14T23:59Z will only be one month as it is one minute short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
+   * This method operates in association with {@link TemporalUnit#between} . The result of this
    * method is a {@code long} representing the amount of the specified unit. By contrast, the result
    * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS}, {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code
-   * CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values
-   * will throw an exception.
+   * The calculation is implemented in this method for {@link ChronoUnit} . The units {@code NANOS}
+   * , {@code MICROS} , {@code MILLIS} , {@code SECONDS} , {@code MINUTES} , {@code HOURS} and
+   * {@code HALF_DAYS}, {@code DAYS} , {@code WEEKS} , {@code MONTHS} , {@code YEARS} ,
+   * {@code DECADES} , {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other
+   * {@code ChronoUnit} values will throw an exception.
    *
    * The calculation for date and time units differ.
    *
@@ -1851,14 +1852,14 @@ final class ZonedDateTime(
    * period from noon on day 1 to noon the following day in hours may be 23, 24 or 25 hours (or some
    * other amount) depending on whether there was a daylight savings change or not.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date-time, which is converted to a { @code ZonedDateTime}, not null
+   *   the end date-time, which is converted to a {@code ZonedDateTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1912,7 +1913,7 @@ final class ZonedDateTime(
   override def toLocalTime: LocalTime = dateTime.toLocalTime
 
   /**
-   * Converts this date-time to an {@code OffsetDateTime}.
+   * Converts this date-time to an {@code OffsetDateTime} .
    *
    * This creates an offset date-time using the local date-time and offset. The zone ID is ignored.
    *
@@ -1949,10 +1950,10 @@ final class ZonedDateTime(
     dateTime.hashCode ^ offset.hashCode ^ Integer.rotateLeft(zone.hashCode, 3)
 
   /**
-   * Outputs this date-time as a {@code String}, such as {@code
+   * Outputs this date-time as a {@code String} , such as {@code
    * 2007-12-03T10:15:30+01:00[Europe/Paris]}.
    *
-   * The format consists of the {@code LocalDateTime} followed by the {@code ZoneOffset}. If the
+   * The format consists of the {@code LocalDateTime} followed by the {@code ZoneOffset} . If the
    * {@code ZoneId} is not the same as the offset, then the ID is output. The output is compatible
    * with ISO-8601 if the offset and ID are the same.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala
index c3ce9a08b..8eb8afcd7 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala
@@ -32,7 +32,7 @@
 package org.threeten.bp.chrono
 
 /**
- * An abstract implementation of {@code Chronology}.
+ * An abstract implementation of {@code Chronology} .
  *
  * <h3>Specification for implementors</h3> This class must be implemented with care to ensure other
  * classes operate correctly. All implementations that can be instantiated must be final, immutable
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala
index 897d6880f..58200dcb9 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala
@@ -86,7 +86,7 @@ object ChronoLocalDate {
    *
    * This obtains a local date based on the specified temporal. A {@code TemporalAccessor}
    * represents an arbitrary set of date and time information, which this factory converts to an
-   * instance of {@code ChronoLocalDate}.
+   * instance of {@code ChronoLocalDate} .
    *
    * The conversion extracts and combines the chronology and the date from the temporal object. The
    * behavior is equivalent to using {@link Chronology#date(TemporalAccessor)} with the extracted
@@ -94,14 +94,14 @@ object ChronoLocalDate {
    * fields that are equivalent to the relevant objects.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ChronoLocalDate::from}.
+   * to be used as a query via method reference, {@code ChronoLocalDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ChronoLocalDate}
+   *   if unable to convert to a {@code ChronoLocalDate}
    * @see
    *   Chronology#date(TemporalAccessor)
    */
@@ -122,12 +122,12 @@ object ChronoLocalDate {
  * A date without time-of-day or time-zone in an arbitrary chronology, intended for advanced
  * globalization use cases.
  *
- * <b>Most applications should declare method signatures, fields and variables as {@link LocalDate},
- * not this interface.</b>
+ * <b>Most applications should declare method signatures, fields and variables as {@link LocalDate}
+ * , not this interface.</b>
  *
  * A {@code ChronoLocalDate} is the abstract representation of a date where the {@code Chronology
  * chronology}, or calendar system, is pluggable. The date is defined in terms of fields expressed
- * by {@link TemporalField}, where most common implementations are defined in {@link ChronoField}.
+ * by {@link TemporalField} , where most common implementations are defined in {@link ChronoField} .
  * The chronology defines how the calendar system operates and the meaning of the standard fields.
  *
  * <h4>When to use this interface</h4> The design of the API encourages the use of {@code LocalDate}
@@ -144,12 +144,12 @@ object ChronoLocalDate {
  * To emphasize the point, declaring a method signature, field or variable as this interface type
  * can initially seem like the sensible way to globalize an application, however it is usually the
  * wrong approach. As such, it should be considered an application-wide architectural decision to
- * choose to use this interface as opposed to {@code LocalDate}.
+ * choose to use this interface as opposed to {@code LocalDate} .
  *
  * <h4>Architectural issues to consider</h4> These are some of the points that must be considered
  * before using this interface throughout an application.
  *
- * 1) Applications using this interface, as opposed to using just {@code LocalDate}, face a
+ * 1) Applications using this interface, as opposed to using just {@code LocalDate} , face a
  * significantly higher probability of bugs. This is because the calendar system in use is not known
  * at development time. A key cause of bugs is where the developer applies assumptions from their
  * day-to-day knowledge of the ISO calendar system to code that is intended to deal with any
@@ -220,7 +220,7 @@ object ChronoLocalDate {
  *
  * <h4>Using LocalDate instead</h4> The primary alternative to using this interface throughout your
  * application is as follows. <ul> <li>Declare all method signatures referring to dates in terms of
- * {@code LocalDate}. <li>Either store the chronology (calendar system) in the user profile or
+ * {@code LocalDate} . <li>Either store the chronology (calendar system) in the user profile or
  * lookup the chronology from the user locale <li>Convert the ISO {@code LocalDate} to and from the
  * user's preferred calendar system during printing and parsing </ul><p> This approach treats the
  * problem of globalized calendar systems as a localization issue and confines it to the UI layer.
@@ -271,10 +271,10 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    *
    * The era is, conceptually, the largest division of the time-line. Most calendar systems have a
    * single epoch dividing the time-line into two eras. However, some have multiple eras, such as
-   * one for the reign of each leader. The exact meaning is determined by the {@code Chronology}.
+   * one for the reign of each leader. The exact meaning is determined by the {@code Chronology} .
    *
    * All correctly implemented {@code Era} classes are singletons, thus it is valid code to write
-   * {@code date.getEra() == SomeEra.NAME)}.
+   * {@code date.getEra() == SomeEra.NAME)} .
    *
    * @return
    *   the chronology specific era constant applicable at this date, not null
@@ -288,7 +288,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    * chronology with the constraint that a leap-year must imply a year-length longer than a non
    * leap-year.
    *
-   * The default implementation uses {@link Chronology#isLeapYear(long)}.
+   * The default implementation uses {@link Chronology#isLeapYear(long)} .
    *
    * @return
    *   true if this date is in a leap year, false otherwise
@@ -355,7 +355,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   def adjustInto(temporal: Temporal): Temporal = temporal.`with`(EPOCH_DAY, toEpochDay)
 
   /**
-   * Calculates the period between this date and another date as a {@code ChronoPeriod}.
+   * Calculates the period between this date and another date as a {@code ChronoPeriod} .
    *
    * This calculates the period between two dates. All supplied chronologies calculate the period
    * using years, months and days, however the {@code ChronoPeriod} API allows the period to be
@@ -401,7 +401,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   }
 
   /**
-   * Combines this date with a time to create a {@code ChronoLocalDateTime}.
+   * Combines this date with a time to create a {@code ChronoLocalDateTime} .
    *
    * This returns a {@code ChronoLocalDateTime} formed from this date at the specified time. All
    * possible combinations of date and time are valid.
@@ -430,7 +430,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    * Compares this date to another date, including the chronology.
    *
    * The comparison is based first on the underlying time-line date, then on the chronology. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@link Comparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code 2012-12-03 (ISO)}</li>
    * <li>{@code 2012-12-04 (ISO)}</li> <li>{@code 2555-12-04 (ThaiBuddhist)}</li> <li>{@code
@@ -531,7 +531,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   }
 
   /**
-   * Outputs this date as a {@code String}.
+   * Outputs this date as a {@code String} .
    *
    * The output will include the full local date and the chronology ID.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala
index 8025dc5f6..1f41b3b8a 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala
@@ -47,7 +47,7 @@ import org.threeten.bp.temporal.TemporalUnit
  * example, the Japanese, Minguo, Thai Buddhist and others.
  *
  * {@code ChronoLocalDate} is built on the generic concepts of year, month and day. The calendar
- * system, represented by a {@link Chronology}, expresses the relationship between the fields and
+ * system, represented by a {@link Chronology} , expresses the relationship between the fields and
  * this class allows the resulting date to be manipulated.
  *
  * Note that not all calendar systems are suitable for use with this class. For example, the Mayan
@@ -79,9 +79,9 @@ import org.threeten.bp.temporal.TemporalUnit
  * the factory for the ChronoLocalDate subclass. </p> To permit the discovery of the additional
  * calendar types the implementation of {@code Chronology} must be registered as a Service
  * implementing the {@code Chronology} interface in the {@code META-INF/Services} file as per the
- * specification of {@link java.util.ServiceLoader}. The subclass must function according to the
+ * specification of {@link java.util.ServiceLoader} . The subclass must function according to the
  * {@code Chronology} class description and must provide its {@link Chronology#getID calendar name}
- * and {@link Chronology#getCalendarType() calendar type}. </p>
+ * and {@link Chronology#getCalendarType() calendar type} . </p>
  *
  * <h3>Specification for implementors</h3> This abstract class must be implemented with care to
  * ensure other classes operate correctly. All implementations that can be instantiated must be
@@ -202,7 +202,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * day-of-month, will be adjusted to ensure that the result is valid. Typically this will select
    * the last valid day of the month.
    *
-   * The default implementation uses {@link #plusYears(long)}.
+   * The default implementation uses {@link #plusYears(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -225,7 +225,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * the day-of-month, will be adjusted to ensure that the result is valid. Typically this will
    * select the last valid day of the month.
    *
-   * The default implementation uses {@link #plusMonths(long)}.
+   * The default implementation uses {@link #plusMonths(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -247,7 +247,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * cause the resulting date to become invalid. If this occurs, then other fields will be adjusted
    * to ensure that the result is valid.
    *
-   * The default implementation uses {@link #plusWeeks(long)}.
+   * The default implementation uses {@link #plusWeeks(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -267,7 +267,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    *
    * This subtracts the specified period in days to the date.
    *
-   * The default implementation uses {@link #plusDays(long)}.
+   * The default implementation uses {@link #plusDays(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala
index 5c8143de3..9f997da6b 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala
@@ -93,7 +93,7 @@ object ChronoLocalDateTime {
    *
    * This obtains a local date-time based on the specified temporal. A {@code TemporalAccessor}
    * represents an arbitrary set of date and time information, which this factory converts to an
-   * instance of {@code ChronoLocalDateTime}.
+   * instance of {@code ChronoLocalDateTime} .
    *
    * The conversion extracts and combines the chronology and the date-time from the temporal object.
    * The behavior is equivalent to using {@link Chronology#localDateTime(TemporalAccessor)} with the
@@ -101,7 +101,7 @@ object ChronoLocalDateTime {
    * those fields that are equivalent to the relevant objects.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ChronoLocalDateTime::from}.
+   * to be used as a query via method reference, {@code ChronoLocalDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
@@ -211,7 +211,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   }
 
   /**
-   * Combines this time with a time-zone to create a {@code ChronoZonedDateTime}.
+   * Combines this time with a time-zone to create a {@code ChronoZonedDateTime} .
    *
    * This returns a {@code ChronoZonedDateTime} formed from this date-time at the specified
    * time-zone. The result will match this date-time as closely as possible. Time-zone rules, such
@@ -240,9 +240,9 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   def atZone(zone: ZoneId): ChronoZonedDateTime[D]
 
   /**
-   * Converts this date-time to an {@code Instant}.
+   * Converts this date-time to an {@code Instant} .
    *
-   * This combines this local date-time and the specified offset to form an {@code Instant}.
+   * This combines this local date-time and the specified offset to form an {@code Instant} .
    *
    * @param offset
    *   the offset to use for the conversion, not null
@@ -276,7 +276,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
    * Compares this date-time to another date-time, including the chronology.
    *
    * The comparison is based first on the underlying time-line date-time, then on the chronology. It
-   * is "consistent with equals", as defined by {@link Comparable}.
+   * is "consistent with equals", as defined by {@link Comparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code 2012-12-03T12:00
    * (ISO)}</li> <li>{@code 2012-12-04T12:00 (ISO)}</li> <li>{@code 2555-12-04T12:00
@@ -379,7 +379,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   override def hashCode: Int = toLocalDate.hashCode ^ toLocalTime.hashCode
 
   /**
-   * Outputs this date-time as a {@code String}.
+   * Outputs this date-time as a {@code String} .
    *
    * The output will include the full local date-time and the chronology ID.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala
index f44fb9e6f..752a0fbe5 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala
@@ -111,7 +111,7 @@ private[chrono] object ChronoLocalDateTimeImpl {
  *
  * This class stores all date and time fields, to a precision of nanoseconds. It does not store or
  * represent a time-zone. For example, the value "2nd October 2007 at 13:45.30.123456789" can be
- * stored in an {@code ChronoLocalDateTime}.
+ * stored in an {@code ChronoLocalDateTime} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala
index 585246818..52a451b2d 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala
@@ -76,7 +76,7 @@ object ChronoPeriod {
  *
  * This interface models a date-based amount of time in a calendar system. While most calendar
  * systems use years, months and days, some do not. Therefore, this interface operates solely in
- * terms of a set of supported units that are defined by the {@code Chronology}. The set of
+ * terms of a set of supported units that are defined by the {@code Chronology} . The set of
  * supported units is fixed for a given chronology. The amount of a supported unit may be set to
  * zero.
  *
@@ -93,11 +93,11 @@ trait ChronoPeriod extends TemporalAmount {
    * Gets the value of the requested unit.
    *
    * The supported units are chronology specific. They will typically be {@link ChronoUnit#YEARS
-   * YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}. Requesting an
+   * YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS} . Requesting an
    * unsupported unit will throw an exception.
    *
    * @param unit
-   *   the { @code TemporalUnit} for which to return the value
+   *   the {@code TemporalUnit} for which to return the value
    * @return
    *   the long value of the unit
    * @throws DateTimeException
@@ -111,8 +111,8 @@ trait ChronoPeriod extends TemporalAmount {
    * Gets the set of units supported by this period.
    *
    * The supported units are chronology specific. They will typically be {@link ChronoUnit#YEARS
-   * YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}. They are returned in
-   * order from largest to smallest.
+   * YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS} . They are returned
+   * in order from largest to smallest.
    *
    * This set can be used in conjunction with {@link #get(TemporalUnit)} to access the entire state
    * of the period.
@@ -177,7 +177,7 @@ trait ChronoPeriod extends TemporalAmount {
    * @param amountToAdd
    *   the period to add, not null
    * @return
-   *   a { @code ChronoPeriod} based on this period with the requested period added, not null
+   *   a {@code ChronoPeriod} based on this period with the requested period added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -195,7 +195,7 @@ trait ChronoPeriod extends TemporalAmount {
    * @param amountToSubtract
    *   the period to subtract, not null
    * @return
-   *   a { @code ChronoPeriod} based on this period with the requested period subtracted, not null
+   *   a {@code ChronoPeriod} based on this period with the requested period subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -212,7 +212,7 @@ trait ChronoPeriod extends TemporalAmount {
    * @param scalar
    *   the scalar to multiply by, not null
    * @return
-   *   a { @code ChronoPeriod} based on this period with the amounts multiplied by the scalar, not
+   *   a {@code ChronoPeriod} based on this period with the amounts multiplied by the scalar, not
    *   null
    * @throws ArithmeticException
    *   if numeric overflow occurs
@@ -227,7 +227,7 @@ trait ChronoPeriod extends TemporalAmount {
    * normalization is performed.
    *
    * @return
-   *   a { @code ChronoPeriod} based on this period with the amounts negated, not null
+   *   a {@code ChronoPeriod} based on this period with the amounts negated, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs, which only happens if one of the units has the value { @code
    *   Long.MIN_VALUE}
@@ -244,7 +244,7 @@ trait ChronoPeriod extends TemporalAmount {
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ChronoPeriod} based on this period with the amounts of each unit normalized, not
+   *   a {@code ChronoPeriod} based on this period with the amounts of each unit normalized, not
    *   null
    * @throws ArithmeticException
    *   if numeric overflow occurs
@@ -327,7 +327,7 @@ trait ChronoPeriod extends TemporalAmount {
   override def hashCode: Int
 
   /**
-   * Outputs this period as a {@code String}.
+   * Outputs this period as a {@code String} .
    *
    * The output will include the period amounts and chronology.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala
index 86342a2bc..22c396486 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala
@@ -45,7 +45,7 @@ import org.threeten.bp.temporal.TemporalUnit
 import org.threeten.bp.temporal.UnsupportedTemporalTypeException
 
 /**
- * An implementation of {@code ChronoPeriod}.
+ * An implementation of {@code ChronoPeriod} .
  */
 @SerialVersionUID(275618735781L)
 final class ChronoPeriodImpl(
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala
index 7923a2049..ffcaa818d 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala
@@ -95,7 +95,7 @@ object ChronoZonedDateTime {
    *
    * This creates a zoned date-time based on the specified temporal. A {@code TemporalAccessor}
    * represents an arbitrary set of date and time information, which this factory converts to an
-   * instance of {@code ChronoZonedDateTime}.
+   * instance of {@code ChronoZonedDateTime} .
    *
    * The conversion extracts and combines the chronology, date, time and zone from the temporal
    * object. The behavior is equivalent to using {@link Chronology#zonedDateTime(TemporalAccessor)}
@@ -103,14 +103,14 @@ object ChronoZonedDateTime {
    * accessing those fields that are equivalent to the relevant objects.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ChronoZonedDateTime::from}.
+   * to be used as a query via method reference, {@code ChronoZonedDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ChronoZonedDateTime}
+   *   if unable to convert to a {@code ChronoZonedDateTime}
    * @see
    *   Chronology#zonedDateTime(TemporalAccessor)
    */
@@ -137,10 +137,10 @@ object ChronoZonedDateTime {
  * ZonedDateTime}, not this interface.</b>
  *
  * A {@code ChronoZonedDateTime} is the abstract representation of an offset date-time where the
- * {@code Chronology chronology}, or calendar system, is pluggable. The date-time is defined in
- * terms of fields expressed by {@link TemporalField}, where most common implementations are defined
- * in {@link ChronoField}. The chronology defines how the calendar system operates and the meaning
- * of the standard fields.
+ * {@code Chronology chronology} , or calendar system, is pluggable. The date-time is defined in
+ * terms of fields expressed by {@link TemporalField} , where most common implementations are
+ * defined in {@link ChronoField} . The chronology defines how the calendar system operates and the
+ * meaning of the standard fields.
  *
  * <h4>When to use this interface</h4> The design of the API encourages the use of {@code
  * ZonedDateTime} rather than this interface, even in the case where the application needs to deal
@@ -259,7 +259,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ZoneChronoDateTime} based on this date-time with the earlier offset, not null
+   *   a {@code ZoneChronoDateTime} based on this date-time with the earlier offset, not null
    * @throws DateTimeException
    *   if no rules can be found for the zone
    * @throws DateTimeException
@@ -281,7 +281,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ChronoZonedDateTime} based on this date-time with the later offset, not null
+   *   a {@code ChronoZonedDateTime} based on this date-time with the later offset, not null
    * @throws DateTimeException
    *   if no rules can be found for the zone
    * @throws DateTimeException
@@ -296,14 +296,14 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * This method changes the time-zone and retains the local date-time. The local date-time is only
    * changed if it is invalid for the new zone.
    *
-   * To change the zone and adjust the local date-time, use {@link #withZoneSameInstant(ZoneId)}.
+   * To change the zone and adjust the local date-time, use {@link #withZoneSameInstant(ZoneId)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param zoneId
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ChronoZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@code ChronoZonedDateTime} based on this date-time with the requested zone, not null
    */
   def withZoneSameLocal(zoneId: ZoneId): ChronoZonedDateTime[D]
 
@@ -316,12 +316,12 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * This method is based on retaining the same instant, thus gaps and overlaps in the local
    * time-line have no effect on the result.
    *
-   * To change the offset while keeping the local time, use {@link #withZoneSameLocal(ZoneId)}.
+   * To change the offset while keeping the local time, use {@link #withZoneSameLocal(ZoneId)} .
    *
    * @param zoneId
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ChronoZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@code ChronoZonedDateTime} based on this date-time with the requested zone, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -370,14 +370,14 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
   }
 
   /**
-   * Converts this date-time to an {@code Instant}.
+   * Converts this date-time to an {@code Instant} .
    *
    * This returns an {@code Instant} representing the same point on the time-line as this date-time.
    * The calculation combines the {@linkplain #toLocalDateTime() local date-time} and {@linkplain
    * #getOffset() offset}.
    *
    * @return
-   *   an { @code Instant} representing the same instant, not null
+   *   an {@code Instant} representing the same instant, not null
    */
   def toInstant: Instant = Instant.ofEpochSecond(toEpochSecond, toLocalTime.getNano.toLong)
 
@@ -403,7 +403,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * Compares this date-time to another date-time, including the chronology.
    *
    * The comparison is based first on the instant, then on the local date-time, then on the zone ID,
-   * then on the chronology. It is "consistent with equals", as defined by {@link Comparable}.
+   * then on the chronology. It is "consistent with equals", as defined by {@link Comparable} .
    *
    * If all the date-time objects being compared are in the same chronology, then the additional
    * chronology stage is not required.
@@ -486,7 +486,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * Checks if this date-time is equal to another date-time.
    *
    * The comparison is based on the offset date-time and the zone. To compare for the same instant
-   * on the time-line, use {@link #compareTo}. Only objects of type {@code ChronoZoneDateTime} are
+   * on the time-line, use {@link #compareTo} . Only objects of type {@code ChronoZoneDateTime} are
    * compared, other types return false.
    *
    * @param obj
@@ -510,7 +510,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
     toLocalDateTime.hashCode ^ getOffset.hashCode ^ Integer.rotateLeft(getZone.hashCode, 3)
 
   /**
-   * Outputs this date-time as a {@code String}.
+   * Outputs this date-time as a {@code String} .
    *
    * The output will include the full zoned date-time and the chronology ID.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala
index a209665ba..2ba126629 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala
@@ -154,7 +154,7 @@ final class ChronoZonedDateTimeImpl[D <: ChronoLocalDate] private (
   Objects.requireNonNull(zone, "zone")
 
   /**
-   * Obtains an instance from an {@code Instant}.
+   * Obtains an instance from an {@code Instant} .
    *
    * @param instant
    *   the instant to create the date-time from, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala
index cc9f29793..47f36b263 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala
@@ -68,20 +68,20 @@ object Chronology {
    * Obtains an instance of {@code Chronology} from a temporal object.
    *
    * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Chronology}. If the specified
+   * converts the arbitrary temporal object to an instance of {@code Chronology} . If the specified
    * temporal object does not have a chronology, {@link IsoChronology} is returned.
    *
-   * The conversion will obtain the chronology using {@link TemporalQueries#chronology()}.
+   * The conversion will obtain the chronology using {@link TemporalQueries#chronology()} .
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Chrono::from}.
+   * to be used in queries via method reference, {@code Chrono::from} .
    *
    * @param temporal
    *   the temporal to convert, not null
    * @return
    *   the chronology, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code Chronology}
+   *   if unable to convert to an {@code Chronology}
    */
   def from(temporal: TemporalAccessor): Chronology = {
     Objects.requireNonNull(temporal, "temporal")
@@ -107,12 +107,12 @@ object Chronology {
    * in Japan with the Japanese calendar system.
    *
    * This method finds the desired calendar system by in a manner equivalent to passing "ca" to
-   * {@link Locale#getUnicodeLocaleType(String)}. If the "ca" key is not present, then {@code
+   * {@link Locale#getUnicodeLocaleType(String)} . If the "ca" key is not present, then {@code
    * IsoChronology} is returned.
    *
    * Note that the behavior of this method differs from the older {@link
    * java.util.Calendar#getInstance(Locale)} method. If that method receives a locale of "th_TH" it
-   * will return {@code BuddhistCalendar}. By contrast, this method will return {@code
+   * will return {@code BuddhistCalendar} . By contrast, this method will return {@code
    * IsoChronology}. Passing the locale "th-TH-u-ca-buddhist" into either method will result in the
    * Thai Buddhist calendar system and is therefore the recommended approach going forward for Thai
    * calendar system localization.
@@ -237,9 +237,10 @@ object Chronology {
  * val thaiYear: Int = thaiDate.get(ChronoField.YEAR);
  * }}}
  * As shown, although the date objects are in different calendar systems, represented by different
- * {@code Chronology} instances, both can be queried using the same constant on {@code ChronoField}.
- * For a full discussion of the implications of this, see {@link ChronoLocalDate}. In general, the
- * advice is to use the known ISO-based {@code LocalDate}, rather than {@code ChronoLocalDate}.
+ * {@code Chronology} instances, both can be queried using the same constant on {@code ChronoField}
+ * . For a full discussion of the implications of this, see {@link ChronoLocalDate} . In general,
+ * the advice is to use the known ISO-based {@code LocalDate} , rather than {@code ChronoLocalDate}
+ * .
  *
  * While a {@code Chronology} object typically uses {@code ChronoField} and is based on an era,
  * year-of-era, month-of-year, day-of-month model of a date, this is not required. A {@code
@@ -264,8 +265,8 @@ object Chronology {
  *
  * <p id="addcalendars">Adding New Calendars</p> The set of available chronologies can be extended
  * by applications. Adding a new calendar system requires the writing of an implementation of {@code
- * Chronology}, {@code ChronoLocalDate} and {@code Era}. The majority of the logic specific to the
- * calendar system will be in {@code ChronoLocalDate}. The {@code Chronology} subclass acts as a
+ * Chronology}, {@code ChronoLocalDate} and {@code Era} . The majority of the logic specific to the
+ * calendar system will be in {@code ChronoLocalDate} . The {@code Chronology} subclass acts as a
  * factory.
  *
  * To permit the discovery of additional chronologies, the {@link java.util.ServiceLoader
@@ -290,7 +291,7 @@ trait Chronology extends Ordered[Chronology] {
    * @param temporal
    *   a date-time to cast, not null
    * @return
-   *   the date-time checked and cast to { @code ChronoLocalDate}, not null
+   *   the date-time checked and cast to {@code ChronoLocalDate} , not null
    * @throws ClassCastException
    *   if the date-time cannot be cast to ChronoLocalDate or the chronology is not equal this Chrono
    */
@@ -309,7 +310,7 @@ trait Chronology extends Ordered[Chronology] {
    * @param temporal
    *   a date-time to cast, not null
    * @return
-   *   the date-time checked and cast to { @code ChronoLocalDateTime}, not null
+   *   the date-time checked and cast to {@code ChronoLocalDateTime} , not null
    * @throws ClassCastException
    *   if the date-time cannot be cast to ChronoLocalDateTimeImpl or the chronology is not equal
    *   this Chrono
@@ -331,7 +332,7 @@ trait Chronology extends Ordered[Chronology] {
    * @param temporal
    *   a date-time to cast, not null
    * @return
-   *   the date-time checked and cast to { @code ChronoZonedDateTimeImpl}, not null
+   *   the date-time checked and cast to {@code ChronoZonedDateTimeImpl} , not null
    * @throws ClassCastException
    *   if the date-time cannot be cast to ChronoZonedDateTimeImpl or the chronology is not equal
    *   this Chrono
@@ -350,8 +351,8 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Gets the ID of the chronology.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@code Chronology} . It can be used to lookup the {@code
+   * Chronology} using {@link #of(String)} .
    *
    * @return
    *   the chronology ID, not null
@@ -392,7 +393,7 @@ trait Chronology extends Ordered[Chronology] {
    * @throws DateTimeException
    *   if unable to create the date
    * @throws ClassCastException
-   *   if the { @code era} is not of the correct type for the chronology
+   *   if the {@code era} is not of the correct type for the chronology
    */
   def date(era: Era, yearOfEra: Int, month: Int, dayOfMonth: Int): ChronoLocalDate =
     date(prolepticYear(era, yearOfEra), month, dayOfMonth)
@@ -428,7 +429,7 @@ trait Chronology extends Ordered[Chronology] {
    * @throws DateTimeException
    *   if unable to create the date
    * @throws ClassCastException
-   *   if the { @code era} is not of the correct type for the chronology
+   *   if the {@code era} is not of the correct type for the chronology
    */
   def dateYearDay(era: Era, yearOfEra: Int, dayOfYear: Int): ChronoLocalDate =
     dateYearDay(prolepticYear(era, yearOfEra), dayOfYear)
@@ -465,7 +466,7 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a local date in this chronology from another temporal object.
    *
-   * This creates a date in this chronology based on the specified {@code TemporalAccessor}.
+   * This creates a date in this chronology based on the specified {@code TemporalAccessor} .
    *
    * The standard mechanism for conversion between date types is the {@link ChronoField#EPOCH_DAY
    * local epoch-day} field.
@@ -489,7 +490,7 @@ trait Chronology extends Ordered[Chronology] {
    * Using this method will prevent the ability to use an alternate clock for testing because the
    * clock is hard-coded.
    *
-   * This implementation uses {@link #dateNow(Clock)}.
+   * This implementation uses {@link #dateNow(Clock)} .
    *
    * @return
    *   the current local date using the system clock and default time-zone, not null
@@ -522,7 +523,7 @@ trait Chronology extends Ordered[Chronology] {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@link Clock dependency injection}.
+   * {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -539,7 +540,7 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a local date-time in this chronology from another temporal object.
    *
-   * This creates a date-time in this chronology based on the specified {@code TemporalAccessor}.
+   * This creates a date-time in this chronology based on the specified {@code TemporalAccessor} .
    *
    * The date of the date-time should be equivalent to that obtained by calling {@link
    * #date(TemporalAccessor)}. The standard mechanism for conversion between time types is the
@@ -567,10 +568,10 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a zoned date-time in this chronology from another temporal object.
    *
-   * This creates a date-time in this chronology based on the specified {@code TemporalAccessor}.
+   * This creates a date-time in this chronology based on the specified {@code TemporalAccessor} .
    *
-   * This should obtain a {@code ZoneId} using {@link ZoneId#from(TemporalAccessor)}. The date-time
-   * should be obtained by obtaining an {@code Instant}. If that fails, the local date-time should
+   * This should obtain a {@code ZoneId} using {@link ZoneId#from(TemporalAccessor)} . The date-time
+   * should be obtained by obtaining an {@code Instant} . If that fails, the local date-time should
    * be used.
    *
    * @param temporal
@@ -604,7 +605,7 @@ trait Chronology extends Ordered[Chronology] {
     }
 
   /**
-   * Obtains a zoned date-time in this chronology from an {@code Instant}.
+   * Obtains a zoned date-time in this chronology from an {@code Instant} .
    *
    * This creates a zoned date-time with the same instant as that specified.
    *
@@ -629,9 +630,9 @@ trait Chronology extends Ordered[Chronology] {
    *
    * The default implementation returns an implementation class suitable for most calendar systems.
    * It is based solely on the three units. Normalization, addition and subtraction derive the
-   * number of months in a year from the {@link #range(ChronoField)}. If the number of months within
-   * a year is fixed, then the calculation approach for addition, subtraction and normalization is
-   * slightly different.
+   * number of months in a year from the {@link #range(ChronoField)} . If the number of months
+   * within a year is fixed, then the calculation approach for addition, subtraction and
+   * normalization is slightly different.
    *
    * If implementing an unusual calendar system that is not based on years, months and days, or
    * where you want direct control, then the {@code ChronoPeriod} interface must be directly
@@ -681,7 +682,7 @@ trait Chronology extends Ordered[Chronology] {
    * @throws DateTimeException
    *   if unable to convert
    * @throws ClassCastException
-   *   if the { @code era} is not of the correct type for the chronology
+   *   if the {@code era} is not of the correct type for the chronology
    */
   def prolepticYear(era: Era, yearOfEra: Int): Int
 
@@ -823,7 +824,7 @@ trait Chronology extends Ordered[Chronology] {
    * Compares this chronology to another chronology.
    *
    * The comparison order first by the chronology ID string, then by any additional information
-   * specific to the subclass. It is "consistent with equals", as defined by {@link Comparable}.
+   * specific to the subclass. It is "consistent with equals", as defined by {@link Comparable} .
    *
    * The default implementation compares the chronology ID. Subclasses must compare any additional
    * state that they store.
@@ -840,7 +841,7 @@ trait Chronology extends Ordered[Chronology] {
    *
    * The comparison is based on the entire state of the object.
    *
-   * The default implementation checks the type and calls {@link #compareTo(Chronology)}.
+   * The default implementation checks the type and calls {@link #compareTo(Chronology)} .
    *
    * @param obj
    *   the object to check, null returns false
@@ -865,7 +866,7 @@ trait Chronology extends Ordered[Chronology] {
   override def hashCode: Int = getClass.hashCode ^ getId.hashCode
 
   /**
-   * Outputs this chronology as a {@code String}, using the ID.
+   * Outputs this chronology as a {@code String} , using the ID.
    *
    * @return
    *   a string representation of this chronology, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala
index b89a806bd..6aa177e0a 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala
@@ -138,8 +138,8 @@ final class HijrahChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'Hijrah-umalqura'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@code Chronology} . It can be used to lookup the {@code
+   * Chronology} using {@link #of(String)} .
    *
    * @return
    *   the chronology ID - 'Hijrah-umalqura'
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala
index 5a882f5bd..2954aa62b 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala
@@ -89,9 +89,9 @@ object HijrahDate {
     Array(30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 30)
 
   /**
-   * <pre> Greatest Least Field name Minimum Minimum Maximum Maximum
-   * ---------- ------- ------- ------- ------- ERA 0 0 1 1 YEAR_OF_ERA 1 1 9999 9999 MONTH_OF_YEAR
-   * 1 1 12 12 DAY_OF_MONTH 1 1 29 30 DAY_OF_YEAR 1 1 354 355 </pre>
+   * <pre> Greatest Least Field name Minimum Minimum Maximum Maximum ---------- ------- -------
+   * ------- ------- ERA 0 0 1 1 YEAR_OF_ERA 1 1 9999 9999 MONTH_OF_YEAR 1 1 12 12 DAY_OF_MONTH 1 1
+   * 29 30 DAY_OF_YEAR 1 1 354 355 </pre>
    *
    * Minimum values.
    */
@@ -293,7 +293,7 @@ object HijrahDate {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@linkplain Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -407,20 +407,20 @@ object HijrahDate {
    *
    * This obtains a date in the Hijrah calendar system based on the specified temporal. A {@code
    * TemporalAccessor} represents an arbitrary set of date and time information, which this factory
-   * converts to an instance of {@code HijrahDate}.
+   * converts to an instance of {@code HijrahDate} .
    *
    * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code HijrahDate::from}.
+   * to be used as a query via method reference, {@code HijrahDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Hijrah calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code HijrahDate}
+   *   if unable to convert to a {@code HijrahDate}
    */
   def from(temporal: TemporalAccessor): HijrahDate = HijrahChronology.INSTANCE.date(temporal)
 
@@ -1144,7 +1144,7 @@ object HijrahDate {
 /**
  * A date in the Hijrah calendar system.
  *
- * This implements {@code ChronoLocalDate} for the {@link HijrahChronology Hijrah calendar}.
+ * This implements {@code ChronoLocalDate} for the {@link HijrahChronology Hijrah calendar} .
  *
  * The Hijrah calendar has a different total of days in a year than Gregorian calendar, and a month
  * is based on the period of a complete revolution of the moon around the earth (as between
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala
index 1d3fc11f2..bbc4b77af 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala
@@ -107,8 +107,8 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'ISO'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@code Chronology} . It can be used to lookup the {@code
+   * Chronology} using {@link #of(String)} .
    *
    * @return
    *   the chronology ID - 'ISO'
@@ -154,7 +154,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date from the proleptic-year, month-of-year and day-of-month fields.
    *
-   * This is equivalent to {@link LocalDate#of(int, int, int)}.
+   * This is equivalent to {@link LocalDate#of(int, int, int)} .
    *
    * @param prolepticYear
    *   the ISO proleptic-year
@@ -190,7 +190,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date from the proleptic-year and day-of-year fields.
    *
-   * This is equivalent to {@link LocalDate#ofYearDay(int, int)}.
+   * This is equivalent to {@link LocalDate#ofYearDay(int, int)} .
    *
    * @param prolepticYear
    *   the ISO proleptic-year
@@ -209,7 +209,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date from another date-time object.
    *
-   * This is equivalent to {@link LocalDate#from(TemporalAccessor)}.
+   * This is equivalent to {@link LocalDate#from(TemporalAccessor)} .
    *
    * @param temporal
    *   the date-time object to convert, not null
@@ -223,7 +223,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date-time from another date-time object.
    *
-   * This is equivalent to {@link LocalDateTime#from(TemporalAccessor)}.
+   * This is equivalent to {@link LocalDateTime#from(TemporalAccessor)} .
    *
    * @param temporal
    *   the date-time object to convert, not null
@@ -238,7 +238,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO zoned date-time from another date-time object.
    *
-   * This is equivalent to {@link ZonedDateTime#from(TemporalAccessor)}.
+   * This is equivalent to {@link ZonedDateTime#from(TemporalAccessor)} .
    *
    * @param temporal
    *   the date-time object to convert, not null
@@ -253,7 +253,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO zoned date-time from an instant.
    *
-   * This is equivalent to {@link ZonedDateTime#ofInstant(Instant, ZoneId)}.
+   * This is equivalent to {@link ZonedDateTime#ofInstant(Instant, ZoneId)} .
    *
    * @param instant
    *   the instant to convert, not null
@@ -304,7 +304,7 @@ final class IsoChronology private () extends Chronology with Serializable {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@link Clock dependency injection}.
+   * {@link Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala
index e41849f7e..8b61592ee 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala
@@ -77,7 +77,7 @@ object MinguoChronology {
  *
  * This chronology defines the rules of the Minguo calendar system. This calendar system is
  * primarily used in the Republic of China, often known as Taiwan. Dates are aligned such that
- * {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)}.
+ * {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)} .
  *
  * The fields are defined as follows: <ul> <li>era - There are two eras, the current 'Republic'
  * (ROC) and the previous era (BEFORE_ROC). <li>year-of-era - The year-of-era for the current era
@@ -106,8 +106,8 @@ final class MinguoChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'Minguo'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@code Chronology} . It can be used to lookup the {@code
+   * Chronology} using {@link #of(String)} .
    *
    * @return
    *   the chronology ID - 'Minguo'
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala
index b986b4538..f00cb0a00 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala
@@ -87,7 +87,7 @@ object MinguoDate {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@linkplain Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -125,20 +125,20 @@ object MinguoDate {
    *
    * This obtains a date in the Minguo calendar system based on the specified temporal. A {@code
    * TemporalAccessor} represents an arbitrary set of date and time information, which this factory
-   * converts to an instance of {@code MinguoDate}.
+   * converts to an instance of {@code MinguoDate} .
    *
    * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code MinguoDate::from}.
+   * to be used as a query via method reference, {@code MinguoDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Minguo calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code MinguoDate}
+   *   if unable to convert to a {@code MinguoDate}
    */
   def from(temporal: TemporalAccessor): MinguoDate = MinguoChronology.INSTANCE.date(temporal)
 
@@ -147,9 +147,9 @@ object MinguoDate {
 /**
  * A date in the Minguo calendar system.
  *
- * This date operates using the {@linkplain MinguoChronology Minguo calendar}. This calendar system
+ * This date operates using the {@linkplain MinguoChronology Minguo calendar} . This calendar system
  * is primarily used in the Republic of China, often known as Taiwan. Dates are aligned such that
- * {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)}.
+ * {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala
index 908f6dac2..39a8e9fbf 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala
@@ -136,8 +136,8 @@ final class ThaiBuddhistChronology private () extends Chronology with Serializab
   /**
    * Gets the ID of the chronology - 'ThaiBuddhist'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@code Chronology} . It can be used to lookup the {@code
+   * Chronology} using {@link #of(String)} .
    *
    * @return
    *   the chronology ID - 'ThaiBuddhist'
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala
index cdc167df6..d37f37994 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala
@@ -87,7 +87,7 @@ object ThaiBuddhistDate {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@linkplain Clock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -125,20 +125,20 @@ object ThaiBuddhistDate {
    *
    * This obtains a date in the Thai Buddhist calendar system based on the specified temporal. A
    * {@code TemporalAccessor} represents an arbitrary set of date and time information, which this
-   * factory converts to an instance of {@code ThaiBuddhistDate}.
+   * factory converts to an instance of {@code ThaiBuddhistDate} .
    *
    * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
    * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ThaiBuddhistDate::from}.
+   * to be used as a query via method reference, {@code ThaiBuddhistDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Thai Buddhist calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ThaiBuddhistDate}
+   *   if unable to convert to a {@code ThaiBuddhistDate}
    */
   def from(temporal: TemporalAccessor): ThaiBuddhistDate =
     ThaiBuddhistChronology.INSTANCE.date(temporal)
@@ -148,9 +148,9 @@ object ThaiBuddhistDate {
 /**
  * A date in the Thai Buddhist calendar system.
  *
- * This date operates using the {@linkplain ThaiBuddhistChronology Thai Buddhist calendar}. This
+ * This date operates using the {@linkplain ThaiBuddhistChronology Thai Buddhist calendar} . This
  * calendar system is primarily used in Thailand. Dates are aligned such that {@code 2484-01-01
- * (Buddhist)} is {@code 1941-01-01 (ISO)}.
+ * (Buddhist)} is {@code 1941-01-01 (ISO)} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala
index e891fabde..d45968822 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala
@@ -39,10 +39,10 @@ package org.threeten.bp
  *
  * The supported calendar systems includes:
  *
- * -{@linkplain org.threeten.bp.chrono.HijrahChronology Hijrah calendar}
- * -{@linkplain org.threeten.bp.chrono.JapaneseChronology Japanese calendar}
- * -{@linkplain org.threeten.bp.chrono.MinguoChronology Minguo calendar}
- * -{@linkplain org.threeten.bp.chrono.ThaiBuddhistChronology Thai Buddhist calendar}
+ * -{@linkplain org.threeten.bp.chrono.HijrahChronology Hijrah calendar} -{@linkplain
+ * org.threeten.bp.chrono.JapaneseChronology Japanese calendar} -{@linkplain
+ * org.threeten.bp.chrono.MinguoChronology Minguo calendar} -{@linkplain
+ * org.threeten.bp.chrono.ThaiBuddhistChronology Thai Buddhist calendar}
  *
  * It is intended that applications use the main API whenever possible, including code to read and
  * write from a persistent data store, such as a database, and to send dates and times across a
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala
index d32e08bc1..24c417be8 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala
@@ -57,8 +57,8 @@ import org.threeten.bp.temporal.TemporalQuery
  *
  * The builder is used to hold onto different elements of date and time. It is designed as two
  * separate maps: <ul> <li>from {@link TemporalField} to {@code long} value, where the value may be
- * outside the valid range for the field <li>from {@code Class} to {@link TemporalAccessor}, holding
- * larger scale objects like {@code LocalDateTime}. </ul><p>
+ * outside the valid range for the field <li>from {@code Class} to {@link TemporalAccessor} ,
+ * holding larger scale objects like {@code LocalDateTime} . </ul><p>
  *
  * <h3>Specification for implementors</h3> This class is mutable and not thread-safe. It should only
  * be used from a single thread.
@@ -134,7 +134,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
    * @param value
    *   the value to add, not null
    * @return
-   *   { @code this}, for method chaining
+   *   {@code this} , for method chaining
    * @throws DateTimeException
    *   if the field is already present with a different value
    */
@@ -166,7 +166,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
    * @param resolverStyle
    *   how to resolve
    * @return
-   *   { @code this}, for method chaining
+   *   {@code this} , for method chaining
    */
   def resolve(
     resolverStyle:  ResolverStyle,
@@ -554,7 +554,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
    * @tparam R
    *   the type to return
    * @param type
-   *   the type to invoke { @code from} on, not null
+   *   the type to invoke {@code from} on, not null
    * @return
    *   the extracted value, not null
    * @throws DateTimeException
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala
index b3ddb6f53..3662d1b05 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala
@@ -72,9 +72,10 @@ object DateTimeFormatter {
    * date format. The format consists of: <ul> <li>Four digits or more for the {@link
    * ChronoField#YEAR year}. Years in the range 0000 to 9999 will be pre-padded by zero to ensure
    * four digits. Years outside that range will have a prefixed positive or negative symbol. <li>A
-   * dash <li>Two digits for the {@link ChronoField#MONTH_OF_YEAR month-of-year}. This is pre-padded
-   * by zero to ensure two digits. <li>A dash <li>Two digits for the {@link ChronoField#DAY_OF_MONTH
-   * day-of-month}. This is pre-padded by zero to ensure two digits. </ul><p>
+   * dash <li>Two digits for the {@link ChronoField#MONTH_OF_YEAR month-of-year} . This is
+   * pre-padded by zero to ensure two digits. <li>A dash <li>Two digits for the {@link
+   * ChronoField#DAY_OF_MONTH day-of-month}. This is pre-padded by zero to ensure two digits.
+   * </ul><p>
    */
   lazy val ISO_LOCAL_DATE: DateTimeFormatter = new DateTimeFormatterBuilder()
     .appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
@@ -109,7 +110,7 @@ object DateTimeFormatter {
    * available to print/parse then the format is complete. <li>The {@link ZoneOffset#getId() offset
    * ID}. If the offset has seconds then they will be handled even though this is not part of the
    * ISO-8601 standard. Parsing is case insensitive. </ul><p> As this formatter has an optional
-   * element, it may be necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * element, it may be necessary to parse using {@link DateTimeFormatter#parseBest} .
    */
   lazy val ISO_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .append(ISO_LOCAL_DATE)
@@ -125,12 +126,12 @@ object DateTimeFormatter {
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended local
    * time format. The format consists of: <ul> <li>Two digits for the {@link ChronoField#HOUR_OF_DAY
    * hour-of-day}. This is pre-padded by zero to ensure two digits. <li>A colon <li>Two digits for
-   * the {@link ChronoField#MINUTE_OF_HOUR minute-of-hour}. This is pre-padded by zero to ensure two
-   * digits. <li>If the second-of-minute is not available to print/parse then the format is
+   * the {@link ChronoField#MINUTE_OF_HOUR minute-of-hour} . This is pre-padded by zero to ensure
+   * two digits. <li>If the second-of-minute is not available to print/parse then the format is
    * complete. <li>A colon <li>Two digits for the {@link ChronoField#SECOND_OF_MINUTE
    * second-of-minute}. This is pre-padded by zero to ensure two digits. <li>If the nano-of-second
    * is zero or not available to print/parse then the format is complete. <li>A decimal point
-   * <li>One to nine digits for the {@link ChronoField#NANO_OF_SECOND nano-of-second}. As many
+   * <li>One to nine digits for the {@link ChronoField#NANO_OF_SECOND nano-of-second} . As many
    * digits will be printed as required. </ul><p>
    */
   lazy val ISO_LOCAL_TIME: DateTimeFormatter = new DateTimeFormatterBuilder()
@@ -198,7 +199,7 @@ object DateTimeFormatter {
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
    * offset date-time format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_DATE_TIME}
-   * <li>The {@link ZoneOffset#getId() offset ID}. If the offset has seconds then they will be
+   * <li>The {@link ZoneOffset#getId() offset ID} . If the offset has seconds then they will be
    * handled even though this is not part of the ISO-8601 standard. Parsing is case insensitive.
    * </ul><p>
    */
@@ -243,7 +244,7 @@ object DateTimeFormatter {
    * ZoneOffset} then the format is complete. <li>An open square bracket '['. <li>The {@link
    * ZoneId#getId() zone ID}. This is not part of the ISO-8601 standard. Parsing is case sensitive.
    * <li>A close square bracket ']'. </ul><p> As this formatter has an optional element, it may be
-   * necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * necessary to parse using {@link DateTimeFormatter#parseBest} .
    */
   lazy val ISO_DATE_TIME: DateTimeFormatter = new DateTimeFormatterBuilder()
     .append(ISO_LOCAL_DATE_TIME)
@@ -265,12 +266,12 @@ object DateTimeFormatter {
    * ordinal date format. The format consists of: <ul> <li>Four digits or more for the {@link
    * ChronoField#YEAR year}. Years in the range 0000 to 9999 will be pre-padded by zero to ensure
    * four digits. Years outside that range will have a prefixed positive or negative symbol. <li>A
-   * dash <li>Three digits for the {@link ChronoField#DAY_OF_YEAR day-of-year}. This is pre-padded
+   * dash <li>Three digits for the {@link ChronoField#DAY_OF_YEAR day-of-year} . This is pre-padded
    * by zero to ensure three digits. <li>If the offset is not available to print/parse then the
-   * format is complete. <li>The {@link ZoneOffset#getId() offset ID}. If the offset has seconds
+   * format is complete. <li>The {@link ZoneOffset#getId() offset ID} . If the offset has seconds
    * then they will be handled even though this is not part of the ISO-8601 standard. Parsing is
    * case insensitive. </ul><p> As this formatter has an optional element, it may be necessary to
-   * parse using {@link DateTimeFormatter#parseBest}.
+   * parse using {@link DateTimeFormatter#parseBest} .
    */
   lazy val ISO_ORDINAL_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
@@ -290,13 +291,13 @@ object DateTimeFormatter {
    * IsoFields#WEEK_BASED_YEAR week-based-year}. Years in the range 0000 to 9999 will be pre-padded
    * by zero to ensure four digits. Years outside that range will have a prefixed positive or
    * negative symbol. <li>A dash <li>The letter 'W'. Parsing is case insensitive. <li>Two digits for
-   * the {@link IsoFields#WEEK_OF_WEEK_BASED_YEAR week-of-week-based-year}. This is pre-padded by
+   * the {@link IsoFields#WEEK_OF_WEEK_BASED_YEAR week-of-week-based-year} . This is pre-padded by
    * zero to ensure three digits. <li>A dash <li>One digit for the {@link ChronoField#DAY_OF_WEEK
    * day-of-week}. The value run from Monday (1) to Sunday (7). <li>If the offset is not available
-   * to print/parse then the format is complete. <li>The {@link ZoneOffset#getId() offset ID}. If
+   * to print/parse then the format is complete. <li>The {@link ZoneOffset#getId() offset ID} . If
    * the offset has seconds then they will be handled even though this is not part of the ISO-8601
    * standard. Parsing is case insensitive. </ul><p> As this formatter has an optional element, it
-   * may be necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * may be necessary to parse using {@link DateTimeFormatter#parseBest} .
    */
   lazy val ISO_WEEK_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .appendValue(IsoFields.WEEK_BASED_YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
@@ -324,7 +325,7 @@ object DateTimeFormatter {
    * point in time and internally stores a value in nanoseconds from a fixed epoch of 1970-01-01Z.
    * As such, an {@code Instant} cannot be formatted as a date or time without providing some form
    * of time-zone. This formatter allows the {@code Instant} to be formatted, by providing a
-   * suitable conversion using {@code ZoneOffset.UTC}.
+   * suitable conversion using {@code ZoneOffset.UTC} .
    *
    * The format consists of: <ul> <li>The {@link #ISO_OFFSET_DATE_TIME} where the instant is
    * converted from {@link ChronoField#INSTANT_SECONDS} and {@link ChronoField#NANO_OF_SECOND} using
@@ -344,12 +345,12 @@ object DateTimeFormatter {
    * date format. The format consists of: <ul> <li>Four digits for the {@link ChronoField#YEAR
    * year}. Only years in the range 0000 to 9999 are supported. <li>Two digits for the {@link
    * ChronoField#MONTH_OF_YEAR month-of-year}. This is pre-padded by zero to ensure two digits.
-   * <li>Two digits for the {@link ChronoField#DAY_OF_MONTH day-of-month}. This is pre-padded by
+   * <li>Two digits for the {@link ChronoField#DAY_OF_MONTH day-of-month} . This is pre-padded by
    * zero to ensure two digits. <li>If the offset is not available to print/parse then the format is
    * complete. <li>The {@link ZoneOffset#getId() offset ID} without colons. If the offset has
    * seconds then they will be handled even though this is not part of the ISO-8601 standard.
    * Parsing is case insensitive. </ul><p> As this formatter has an optional element, it may be
-   * necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * necessary to parse using {@link DateTimeFormatter#parseBest} .
    */
   lazy val BASIC_ISO_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .appendValue(YEAR, 4)
@@ -370,13 +371,13 @@ object DateTimeFormatter {
    *
    * The format consists of: <ul> <li>If the day-of-week is not available to print/parse then jump
    * to day-of-month. <li>Three letter {@link ChronoField#DAY_OF_WEEK day-of-week} in English. <li>A
-   * comma <li>A space <li>One or two digits for the {@link ChronoField#DAY_OF_MONTH day-of-month}.
+   * comma <li>A space <li>One or two digits for the {@link ChronoField#DAY_OF_MONTH day-of-month} .
    * <li>A space <li>Three letter {@link ChronoField#MONTH_OF_YEAR month-of-year} in English. <li>A
-   * space <li>Four digits for the {@link ChronoField#YEAR year}. Only years in the range 0000 to
+   * space <li>Four digits for the {@link ChronoField#YEAR year} . Only years in the range 0000 to
    * 9999 are supported. <li>A space <li>Two digits for the {@link ChronoField#HOUR_OF_DAY
    * hour-of-day}. This is pre-padded by zero to ensure two digits. <li>A colon <li>Two digits for
-   * the {@link ChronoField#MINUTE_OF_HOUR minute-of-hour}. This is pre-padded by zero to ensure two
-   * digits. <li>If the second-of-minute is not available to print/parse then jump to the next
+   * the {@link ChronoField#MINUTE_OF_HOUR minute-of-hour} . This is pre-padded by zero to ensure
+   * two digits. <li>If the second-of-minute is not available to print/parse then jump to the next
    * space. <li>A colon <li>Two digits for the {@link ChronoField#SECOND_OF_MINUTE
    * second-of-minute}. This is pre-padded by zero to ensure two digits. <li>A space <li>The {@link
    * ZoneOffset#getId() offset ID} without colons or seconds. An offset of zero uses "GMT". North
@@ -440,10 +441,9 @@ object DateTimeFormatter {
    * DateTimeFormatter#withLocale(Locale)}.
    *
    * All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters. The following pattern
-   * letters are defined: <pre> Symbol Meaning Presentation Examples
-   * ------ ------- ------------ ------- G era number/text 1; 01; AD; Anno Domini y year year 2004;
-   * 04 D day-of-year number 189 M month-of-year number/text 7; 07; Jul; July; J d day-of-month
-   * number 10
+   * letters are defined: <pre> Symbol Meaning Presentation Examples ------ ------- ------------
+   * ------- G era number/text 1; 01; AD; Anno Domini y year year 2004; 04 D day-of-year number 189
+   * M month-of-year number/text 7; 07; Jul; July; J d day-of-month number 10
    *
    * Q quarter-of-year number/text 3; 03; Q3 Y week-based-year year 1996; 96 w week-of-year number
    * 27 W week-of-month number 27 e localized day-of-week number 2; Tue; Tuesday; T E day-of-week
@@ -469,9 +469,9 @@ object DateTimeFormatter {
    * The count of pattern letters determine the format.
    *
    * <b>Text</b>: The text style is determined based on the number of pattern letters used. Less
-   * than 4 pattern letters will use the {@link TextStyle#SHORT short form}. Exactly 4 pattern
-   * letters will use the {@link TextStyle#FULL full form}. Exactly 5 pattern letters will use the
-   * {@link TextStyle#NARROW narrow form}.
+   * than 4 pattern letters will use the {@link TextStyle#SHORT short form} . Exactly 4 pattern
+   * letters will use the {@link TextStyle#FULL full form} . Exactly 5 pattern letters will use the
+   * {@link TextStyle#NARROW narrow form} .
    *
    * <b>Number</b>: If the count of letters is one, then the value is printed using the minimum
    * number of digits and without padding as per {@link
@@ -494,7 +494,7 @@ object DateTimeFormatter {
    * reduced} two digit form is used. For printing, this outputs the rightmost two digits. For
    * parsing, this will parse using the base value of 2000, resulting in a year within the range
    * 2000 to 2099 inclusive. If the count of letters is less than four (but not two), then the sign
-   * is only output for negative years as per {@link SignStyle#NORMAL}. Otherwise, the sign is
+   * is only output for negative years as per {@link SignStyle#NORMAL} . Otherwise, the sign is
    * output if the pad width is exceeded, as per {@link SignStyle#EXCEEDS_PAD}
    *
    * <b>ZoneId</b>: This outputs the time-zone ID, such as 'Europe/Paris'. If the count of letters
@@ -503,7 +503,7 @@ object DateTimeFormatter {
    *
    * <b>Zone names</b>: This outputs the display name of the time-zone ID. If the count of letters
    * is one, two or three, then the short name is output. If the count of letters is four, then the
-   * full name is output. Five or more letters throws {@code IllegalArgumentException}.
+   * full name is output. Five or more letters throws {@code IllegalArgumentException} .
    *
    * <b>Offset X and x</b>: This formats the offset based on the number of pattern letters. One
    * letter outputs just the hour', such as '+01', unless the minute is non-zero in which case the
@@ -511,21 +511,21 @@ object DateTimeFormatter {
    * colon, such as '+0130'. Three letters outputs the hour and minute, with a colon, such as
    * '+01:30'. Four letters outputs the hour and minute and optional second, without a colon, such
    * as '+013015'. Five letters outputs the hour and minute and optional second, with a colon, such
-   * as '+01:30:15'. Six or more letters throws {@code IllegalArgumentException}. Pattern letter 'X'
-   * (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern letter
-   * 'x' (lower case) will output '+00', '+0000', or '+00:00'.
+   * as '+01:30:15'. Six or more letters throws {@code IllegalArgumentException} . Pattern letter
+   * 'X' (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern
+   * letter 'x' (lower case) will output '+00', '+0000', or '+00:00'.
    *
    * <b>Offset Z</b>: This formats the offset based on the number of pattern letters. One, two or
    * three letters outputs the hour and minute, without a colon, such as '+0130'. Four or more
-   * letters throws {@code IllegalArgumentException}. The output will be '+0000' when the offset is
+   * letters throws {@code IllegalArgumentException} . The output will be '+0000' when the offset is
    * zero.
    *
    * <b>Optional section</b>: The optional section markers work exactly like calling {@link
-   * DateTimeFormatterBuilder#optionalStart()} and {@link DateTimeFormatterBuilder#optionalEnd()}.
+   * DateTimeFormatterBuilder#optionalStart()} and {@link DateTimeFormatterBuilder#optionalEnd()} .
    *
    * <b>Pad modifier</b>: Modifies the pattern that immediately follows to be padded with spaces.
    * The pad width is determined by the number of pattern letters. This is the same as calling
-   * {@link DateTimeFormatterBuilder#padNext(int)}.
+   * {@link DateTimeFormatterBuilder#padNext(int)} .
    *
    * For example, 'ppH' outputs the hour-of-day padded on the left with spaces to a width of 2.
    *
@@ -578,7 +578,7 @@ object DateTimeFormatter {
    * locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
+   * will use the {@link Locale#getDefault() default locale} . The locale can be controlled using
    * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
    * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
@@ -604,7 +604,7 @@ object DateTimeFormatter {
    * locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
+   * will use the {@link Locale#getDefault() default locale} . The locale can be controlled using
    * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
    * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
@@ -630,7 +630,7 @@ object DateTimeFormatter {
    * varies by locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
+   * will use the {@link Locale#getDefault() default locale} . The locale can be controlled using
    * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
    * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
@@ -656,7 +656,7 @@ object DateTimeFormatter {
    * varies by locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
+   * will use the {@link Locale#getDefault() default locale} . The locale can be controlled using
    * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
    * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
@@ -839,7 +839,7 @@ object DateTimeFormatter {
  * For more complex formatters, a {@link DateTimeFormatterBuilder builder} is provided.
  *
  * In most cases, it is not necessary to use this class directly when formatting. The main date-time
- * classes provide two methods - one for formatting, {@code format(DateTimeFormatter formatter)},
+ * classes provide two methods - one for formatting, {@code format(DateTimeFormatter formatter)} ,
  * and one for parsing, For example: <pre> String text = date.format(formatter); LocalDate date =
  * LocalDate.parse(text, formatter); </pre> Some aspects of printing and parsing are dependent on
  * the locale. The locale can be changed using the {@link #withLocale(Locale)} method which returns
@@ -973,7 +973,7 @@ final class DateTimeFormatter private[format] (
    * When printing, if the {@code Temporal} object contains a date then it will be converted to a
    * date in the override chronology. Any time or zone will be retained unless overridden. The
    * converted result will behave in a manner equivalent to an implementation of {@code
-   * ChronoLocalDate},{@code ChronoLocalDateTime} or {@code ChronoZonedDateTime}.
+   * ChronoLocalDate},{@code ChronoLocalDateTime} or {@code ChronoZonedDateTime} .
    *
    * When parsing, the override chronology will be used to interpret the {@linkplain ChronoField
    * fields} into a date unless the formatter directly parses a valid chronology.
@@ -1019,9 +1019,9 @@ final class DateTimeFormatter private[format] (
    *
    * When printing, if the {@code Temporal} object contains an instant then it will be converted to
    * a zoned date-time using the override zone. If the input has a chronology then it will be
-   * retained unless overridden. If the input does not have a chronology, such as {@code Instant},
+   * retained unless overridden. If the input does not have a chronology, such as {@code Instant} ,
    * then the ISO chronology will be used. The converted result will behave in a manner equivalent
-   * to an implementation of {@code ChronoZonedDateTime}.
+   * to an implementation of {@code ChronoZonedDateTime} .
    *
    * When parsing, the override zone will be used to interpret the {@linkplain ChronoField fields}
    * into an instant unless the formatter directly parses a valid zone.
@@ -1240,9 +1240,9 @@ final class DateTimeFormatter private[format] (
    *
    * This formats the date-time to the specified destination. {@link Appendable} is a general
    * purpose interface that is implemented by all key character output classes including {@code
-   * StringBuffer}, {@code StringBuilder}, {@code PrintStream} and {@code Writer}.
+   * StringBuffer}, {@code StringBuilder} , {@code PrintStream} and {@code Writer} .
    *
-   * Although {@code Appendable} methods throw an {@code IOException}, this method does not.
+   * Although {@code Appendable} methods throw an {@code IOException} , this method does not.
    * Instead, any {@code IOException} is wrapped in a runtime exception.
    *
    * @param temporal
@@ -1276,7 +1276,7 @@ final class DateTimeFormatter private[format] (
    * Fully parses the text producing a temporal object.
    *
    * This parses the entire text producing a temporal object. It is typically more useful to use
-   * {@link #parse(CharSequence, TemporalQuery)}. The result of this method is {@code
+   * {@link #parse(CharSequence, TemporalQuery)} . The result of this method is {@code
    * TemporalAccessor} which has been resolved, applying basic validation checks to help ensure a
    * valid date-time.
    *
@@ -1306,13 +1306,13 @@ final class DateTimeFormatter private[format] (
    * finish at the end. The result of this method is {@code TemporalAccessor} which has been
    * resolved, applying basic validation checks to help ensure a valid date-time.
    *
-   * The text will be parsed from the specified start {@code ParsePosition}. The entire length of
+   * The text will be parsed from the specified start {@code ParsePosition} . The entire length of
    * the text does not have to be parsed, the {@code ParsePosition} will be updated with the index
    * at the end of parsing.
    *
    * The operation of this method is slightly different to similar methods using {@code
-   * ParsePosition} on {@code java.text.Format}. That class will return errors using the error index
-   * on the {@code ParsePosition}. By contrast, this method will throw a {@link
+   * ParsePosition} on {@code java.text.Format} . That class will return errors using the error
+   * index on the {@code ParsePosition} . By contrast, this method will throw a {@link
    * DateTimeParseException} if an error occurs, with the exception containing the error index. This
    * change in behavior is necessary due to the increased complexity of parsing and resolving
    * dates/times in this API.
@@ -1378,10 +1378,10 @@ final class DateTimeFormatter private[format] (
    * Fully parses the text producing an object of one of the specified types.
    *
    * This parse method is convenient for use when the parser can handle optional elements. For
-   * example, a pattern of 'yyyy[-MM[-dd]]' can be fully parsed to a {@code LocalDate}, or partially
-   * parsed to a {@code YearMonth} or a {@code Year}. The types must be specified in order, starting
-   * from the best matching full-parse option and ending with the worst matching minimal parse
-   * option.
+   * example, a pattern of 'yyyy[-MM[-dd]]' can be fully parsed to a {@code LocalDate} , or
+   * partially parsed to a {@code YearMonth} or a {@code Year} . The types must be specified in
+   * order, starting from the best matching full-parse option and ending with the worst matching
+   * minimal parse option.
    *
    * The result is associated with the first type that successfully parses. Normally, applications
    * will use {@code instanceof} to check the result. For example: <pre> TemporalAccessor dt =
@@ -1392,7 +1392,7 @@ final class DateTimeFormatter private[format] (
    * @param text
    *   the text to parse, not null
    * @param types
-   *   the types to attempt to parse to, which must implement { @code TemporalAccessor}, not null
+   *   the types to attempt to parse to, which must implement {@code TemporalAccessor} , not null
    * @return
    *   the parsed date-time, not null
    * @throws IllegalArgumentException
@@ -1482,7 +1482,7 @@ final class DateTimeFormatter private[format] (
    *
    * Parsing is implemented as a two-phase operation. First, the text is parsed using the layout
    * defined by the formatter, producing a {@code Map} of field to value, a {@code ZoneId} and a
-   * {@code Chronology}. Second, the parsed data is <em>resolved</em>, by validating, combining and
+   * {@code Chronology} . Second, the parsed data is <em>resolved</em>, by validating, combining and
    * simplifying the various fields into more useful ones. This method performs the parsing stage
    * but not the resolving stage.
    *
@@ -1490,7 +1490,7 @@ final class DateTimeFormatter private[format] (
    * input. Values are not validated, thus parsing a date string of '2012-00-65' would result in a
    * temporal with three fields - year of '2012', month of '0' and day-of-month of '65'.
    *
-   * The text will be parsed from the specified start {@code ParsePosition}. The entire length of
+   * The text will be parsed from the specified start {@code ParsePosition} . The entire length of
    * the text does not have to be parsed, the {@code ParsePosition} will be updated with the index
    * at the end of parsing.
    *
@@ -1551,9 +1551,9 @@ final class DateTimeFormatter private[format] (
    * Returns this formatter as a {@code java.text.Format} instance.
    *
    * The returned {@link Format} instance will print any {@link TemporalAccessor} and parses to a
-   * resolved {@link TemporalAccessor}.
+   * resolved {@link TemporalAccessor} .
    *
-   * Exceptions will follow the definitions of {@code Format}, see those methods for details about
+   * Exceptions will follow the definitions of {@code Format} , see those methods for details about
    * {@code IllegalArgumentException} during formatting and {@code ParseException} or null during
    * parsing. The format does not support attributing of the returned format string.
    *
@@ -1567,9 +1567,9 @@ final class DateTimeFormatter private[format] (
    * type.
    *
    * The returned {@link Format} instance will print any {@link TemporalAccessor} and parses to the
-   * type specified. The type must be one that is supported by {@link #parse}.
+   * type specified. The type must be one that is supported by {@link #parse} .
    *
-   * Exceptions will follow the definitions of {@code Format}, see those methods for details about
+   * Exceptions will follow the definitions of {@code Format} , see those methods for details about
    * {@code IllegalArgumentException} during formatting and {@code ParseException} or null during
    * parsing. The format does not support attributing of the returned format string.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala
index b5066dfe9..fabfcf89e 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala
@@ -152,7 +152,7 @@ object DateTimeFormatterBuilder {
  * The basic elements of date-time can all be added: <ul> <li>Value - a numeric value</li>
  * <li>Fraction - a fractional value including the decimal place. Always use this when outputting
  * fractions to ensure that the fraction is parsed correctly</li> <li>Text - the textual equivalent
- * for the value</li> <li>OffsetId/Offset - the {@linkplain ZoneOffset zone offset}</li> <li>ZoneId
+ * for the value</li> <li>OffsetId/Offset - the {@linkplain ZoneOffset zone offset} </li> <li>ZoneId
  *   - the {@linkplain ZoneId time-zone} id</li> <li>ZoneText - the name of the time-zone</li>
  *     <li>Literal - a text literal</li> <li>Nested and Optional - formats can be nested or made
  *     optional</li> <li>Other - the printer and parser interfaces can be used to add user supplied
@@ -160,7 +160,7 @@ object DateTimeFormatterBuilder {
  *     with spaces or any other character.
  *
  * Finally, a shorthand pattern, mostly compatible with {@code java.text.SimpleDateFormat
- * SimpleDateFormat} can be used, see {@link #appendPattern(String)}. In practice, this simply
+ * SimpleDateFormat} can be used, see {@link #appendPattern(String)} . In practice, this simply
  * parses the pattern and calls other methods on the builder.
  *
  * <h3>Specification for implementors</h3> This class is a mutable builder intended for use from a
@@ -211,7 +211,7 @@ final class DateTimeFormatterBuilder private (
    * parse.
    *
    * Since the default is case sensitive, this method should only be used after a previous call to
-   * {@code #parseCaseInsensitive}.
+   * {@code #parseCaseInsensitive} .
    *
    * @return
    *   this, for chaining, not null
@@ -248,7 +248,7 @@ final class DateTimeFormatterBuilder private (
    * flexibility in matching the text and sign styles.
    *
    * When used, this method changes the parsing to be strict from this point onwards. As strict is
-   * the default, this is normally only needed after calling {@link #parseLenient()}. The change
+   * the default, this is normally only needed after calling {@link #parseLenient()} . The change
    * will remain in force until the end of the formatter that is eventually constructed or until
    * {@code parseLenient} is called.
    *
@@ -266,7 +266,7 @@ final class DateTimeFormatterBuilder private (
    *
    * Parsing can be strict or lenient - by default its strict. This controls the degree of
    * flexibility in matching the text and sign styles. Applications calling this method should
-   * typically also call {@link #parseCaseInsensitive()}.
+   * typically also call {@link #parseCaseInsensitive()} .
    *
    * When used, this method changes the parsing to be strict from this point onwards. The change
    * will remain in force until the end of the formatter that is eventually constructed or until
@@ -412,11 +412,11 @@ final class DateTimeFormatterBuilder private (
    * digits as possible. This behavior can be affected by 'adjacent value parsing'. See {@link
    * #appendValue(TemporalField, int)} for full details.
    *
-   * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}. In lenient
+   * In strict parsing mode, the minimum number of parsed digits is {@code minWidth} . In lenient
    * parsing mode, the minimum number of parsed digits is one.
    *
    * If this method is invoked with equal minimum and maximum widths and a sign style of {@code
-   * NOT_NEGATIVE} then it delegates to {@code appendValue(TemporalField,int)}. In this scenario,
+   * NOT_NEGATIVE} then it delegates to {@code appendValue(TemporalField,int)} . In this scenario,
    * the printing and parsing behavior described there occur.
    *
    * @param field
@@ -470,7 +470,7 @@ final class DateTimeFormatterBuilder private (
    * For formatting, the {@code width} and {@code maxWidth} are used to determine the number of
    * characters to format. If they are equal then the format is fixed width. If the value of the
    * field is within the range of the {@code baseValue} using {@code width} characters then the
-   * reduced value is formatted otherwise the value is truncated to fit {@code maxWidth}. The
+   * reduced value is formatted otherwise the value is truncated to fit {@code maxWidth} . The
    * rightmost characters are output to match the width, left padding with zero.
    *
    * For strict parsing, the number of characters allowed by {@code width} to {@code maxWidth} are
@@ -482,9 +482,9 @@ final class DateTimeFormatterBuilder private (
    * absolute values can be entered for values outside the range.
    *
    * For example, a base value of {@code 1980} and a width of {@code 2} will have valid values from
-   * {@code 1980} to {@code 2079}. During parsing, the text {@code "12"} will result in the value
+   * {@code 1980} to {@code 2079} . During parsing, the text {@code "12"} will result in the value
    * {@code 2012} as that is the value within the range where the last two characters are "12". By
-   * contrast, parsing the text {@code "1915"} will result in the value {@code 1915}.
+   * contrast, parsing the text {@code "1915"} will result in the value {@code 1915} .
    *
    * @param field
    *   the field to append, not null
@@ -532,7 +532,7 @@ final class DateTimeFormatterBuilder private (
    * For formatting, the {@code width} and {@code maxWidth} are used to determine the number of
    * characters to format. If they are equal then the format is fixed width. If the value of the
    * field is within the range of the {@code baseValue} using {@code width} characters then the
-   * reduced value is formatted otherwise the value is truncated to fit {@code maxWidth}. The
+   * reduced value is formatted otherwise the value is truncated to fit {@code maxWidth} . The
    * rightmost characters are output to match the width, left padding with zero.
    *
    * For strict parsing, the number of characters allowed by {@code width} to {@code maxWidth} are
@@ -544,9 +544,9 @@ final class DateTimeFormatterBuilder private (
    * absolute values can be entered for values outside the range.
    *
    * For example, a base value of {@code 1980} and a width of {@code 2} will have valid values from
-   * {@code 1980} to {@code 2079}. During parsing, the text {@code "12"} will result in the value
+   * {@code 1980} to {@code 2079} . During parsing, the text {@code "12"} will result in the value
    * {@code 2012} as that is the value within the range where the last two characters are "12". By
-   * contrast, parsing the text {@code "1915"} will result in the value {@code 1915}.
+   * contrast, parsing the text {@code "1915"} will result in the value {@code 1915} .
    *
    * @param field
    *   the field to append, not null
@@ -616,7 +616,7 @@ final class DateTimeFormatterBuilder private (
    *
    * The fractional value of the field will be output including the preceding decimal point. The
    * preceding value is not output. For example, the second-of-minute value of 15 would be output as
-   * {@code .25}.
+   * {@code .25} .
    *
    * The width of the printed fraction can be controlled. Setting the minimum width to zero will
    * cause no output to be generated. The printed fraction will have the minimum width necessary
@@ -782,7 +782,7 @@ final class DateTimeFormatterBuilder private (
    *
    * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS} and
    * optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS} may be outside the
-   * maximum range of {@code LocalDateTime}.
+   * maximum range of {@code LocalDateTime} .
    *
    * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing. The end-of-day
    * time of '24:00' is handled as midnight at the start of the following day. The leap-second time
@@ -790,7 +790,7 @@ final class DateTimeFormatterBuilder private (
    * full details.
    *
    * An alternative to this method is to format/parse the instant as a single epoch-seconds value.
-   * That is achieved using {@code appendValue(INSTANT_SECONDS)}.
+   * That is achieved using {@code appendValue(INSTANT_SECONDS)} .
    *
    * @return
    *   this, for chaining, not null
@@ -818,7 +818,7 @@ final class DateTimeFormatterBuilder private (
    *
    * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS} and
    * optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS} may be outside the
-   * maximum range of {@code LocalDateTime}.
+   * maximum range of {@code LocalDateTime} .
    *
    * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing. The end-of-day
    * time of '24:00' is handled as midnight at the start of the following day. The leap-second time
@@ -826,7 +826,7 @@ final class DateTimeFormatterBuilder private (
    * full details.
    *
    * An alternative to this method is to format/parse the instant as a single epoch-seconds value.
-   * That is achieved using {@code appendValue(INSTANT_SECONDS)}.
+   * That is achieved using {@code appendValue(INSTANT_SECONDS)} .
    *
    * @param fractionalDigits
    *   the number of fractional second digits to format with, from 0 to 9, or -1 to use as many
@@ -846,7 +846,7 @@ final class DateTimeFormatterBuilder private (
    * Appends the zone offset, such as '+01:00', to the formatter.
    *
    * This appends an instruction to print/parse the offset ID to the builder. This is equivalent to
-   * calling {@code appendOffset("HH:MM:ss", "Z")}.
+   * calling {@code appendOffset("HH:MM:ss", "Z")} .
    *
    * @return
    *   this, for chaining, not null
@@ -862,7 +862,7 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to print/parse the offset ID to the builder.
    *
    * During printing, the offset is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#offset()}. It will be printed using the format defined below. If
+   * with {@link TemporalQueries#offset()} . It will be printed using the format defined below. If
    * the offset cannot be obtained then an exception is thrown unless the section of the formatter
    * is optional.
    *
@@ -904,7 +904,7 @@ final class DateTimeFormatterBuilder private (
    * minute and second if non-zero, and colon. </ul>
    *
    * During formatting, the offset is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#offset()}. If the offset cannot be obtained then an exception is
+   * with {@link TemporalQueries#offset()} . If the offset cannot be obtained then an exception is
    * thrown unless the section of the formatter is optional.
    *
    * During parsing, the offset is parsed using the format defined above. If the offset cannot be
@@ -915,7 +915,7 @@ final class DateTimeFormatterBuilder private (
    * @return
    *   this, for chaining, not null
    * @throws IllegalArgumentException
-   *   if style is neither { @link TextStyle#FULL full} nor { @link TextStyle#SHORT short}
+   *   if style is neither {@link TextStyle#FULL full} nor {@link TextStyle#SHORT short}
    */
   def appendLocalizedOffset(style: TextStyle): DateTimeFormatterBuilder = {
     Objects.requireNonNull(style, "style")
@@ -929,11 +929,12 @@ final class DateTimeFormatterBuilder private (
    * Appends the time-zone ID, such as 'Europe/Paris' or '+02:00', to the formatter.
    *
    * This appends an instruction to print/parse the zone ID to the builder. The zone ID is obtained
-   * in a strict manner suitable for {@code ZonedDateTime}. By contrast, {@code OffsetDateTime} does
-   * not have a zone ID suitable for use with this method, see {@link #appendZoneOrOffsetId()}.
+   * in a strict manner suitable for {@code ZonedDateTime} . By contrast, {@code OffsetDateTime}
+   * does not have a zone ID suitable for use with this method, see {@link #appendZoneOrOffsetId()}
+   * .
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. It will be printed using the result of {@link
+   * with {@link TemporalQueries#zoneId()} . It will be printed using the result of {@link
    * ZoneId#getId()}. If the zone cannot be obtained then an exception is thrown unless the section
    * of the formatter is optional.
    *
@@ -954,13 +955,13 @@ final class DateTimeFormatterBuilder private (
 
   /**
    * Appends the time-zone region ID, such as 'Europe/Paris', to the formatter, rejecting the zone
-   * ID if it is a {@code ZoneOffset}.
+   * ID if it is a {@code ZoneOffset} .
    *
    * This appends an instruction to print/parse the zone ID to the builder only if it is a
    * region-based ID.
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. If the zone is a {@code ZoneOffset} or it cannot be
+   * with {@link TemporalQueries#zoneId()} . If the zone is a {@code ZoneOffset} or it cannot be
    * obtained then an exception is thrown unless the section of the formatter is optional. If the
    * zone is not an offset, then the zone will be printed using the zone ID from {@link
    * ZoneId#getId()}.
@@ -968,7 +969,7 @@ final class DateTimeFormatterBuilder private (
    * During parsing, the zone is parsed and must match a known zone or offset. If the zone cannot be
    * parsed then an exception is thrown unless the section of the formatter is optional. Note that
    * parsing accepts offsets, whereas printing will never produce one, thus parsing is equivalent to
-   * {@code appendZoneId}.
+   * {@code appendZoneId} .
    *
    * @return
    *   this, for chaining, not null
@@ -991,11 +992,11 @@ final class DateTimeFormatterBuilder private (
    *
    * This appends an instruction to print/parse the best available zone or offset ID to the builder.
    * The zone ID is obtained in a lenient manner that first attempts to find a true zone ID, such as
-   * that on {@code ZonedDateTime}, and then attempts to find an offset, such as that on {@code
+   * that on {@code ZonedDateTime} , and then attempts to find an offset, such as that on {@code
    * OffsetDateTime}.
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zone()}. It will be printed using the result of {@link
+   * with {@link TemporalQueries#zone()} . It will be printed using the result of {@link
    * ZoneId#getId()}. If the zone cannot be obtained then an exception is thrown unless the section
    * of the formatter is optional.
    *
@@ -1023,9 +1024,9 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to print the textual name of the zone to the builder.
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. If the zone is a {@code ZoneOffset} it will be printed
-   * using the result of {@link ZoneOffset#getId()}. If the zone is not an offset, the textual name
-   * will be looked up for the locale set in the {@link DateTimeFormatter}. If the temporal object
+   * with {@link TemporalQueries#zoneId()} . If the zone is a {@code ZoneOffset} it will be printed
+   * using the result of {@link ZoneOffset#getId()} . If the zone is not an offset, the textual name
+   * will be looked up for the locale set in the {@link DateTimeFormatter} . If the temporal object
    * being printed represents an instant, then the text will be the summer or winter time text as
    * appropriate. If the lookup for text does not find any suitable reuslt, then the {@link
    * ZoneId#getId() ID} will be printed instead. If the zone cannot be obtained then an exception is
@@ -1049,9 +1050,9 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to format/parse the textual name of the zone to the builder.
    *
    * During formatting, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. If the zone is a {@code ZoneOffset} it will be printed
-   * using the result of {@link ZoneOffset#getId()}. If the zone is not an offset, the textual name
-   * will be looked up for the locale set in the {@link DateTimeFormatter}. If the temporal object
+   * with {@link TemporalQueries#zoneId()} . If the zone is a {@code ZoneOffset} it will be printed
+   * using the result of {@link ZoneOffset#getId()} . If the zone is not an offset, the textual name
+   * will be looked up for the locale set in the {@link DateTimeFormatter} . If the temporal object
    * being printed represents an instant, then the text will be the summer or winter time text as
    * appropriate. If the lookup for text does not find any suitable result, then the {@link
    * ZoneId#getId() ID} will be printed instead. If the zone cannot be obtained then an exception is
@@ -1104,8 +1105,8 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to format/parse the chronology ID to the builder.
    *
    * During printing, the chronology is obtained using a mechanism equivalent to querying the
-   * temporal with {@link TemporalQueries#chronology()}. It will be printed using the result of
-   * {@link Chronology#getId()}. If the chronology cannot be obtained then an exception is thrown
+   * temporal with {@link TemporalQueries#chronology()} . It will be printed using the result of
+   * {@link Chronology#getId()} . If the chronology cannot be obtained then an exception is thrown
    * unless the section of the formatter is optional.
    *
    * During parsing, the chronology is parsed and must match one of the chronologies in {@link
@@ -1138,7 +1139,7 @@ final class DateTimeFormatterBuilder private (
    * as the fallback.
    *
    * Note that this method provides similar functionality to methods on {@code DateFormat} such as
-   * {@link DateFormat#getDateTimeInstance(int, int)}.
+   * {@link DateFormat#getDateTimeInstance(int, int)} .
    *
    * @param dateStyle
    *   the date style to use, null means no date required
@@ -1214,7 +1215,7 @@ final class DateTimeFormatterBuilder private (
    * Appends a formatter to the builder which will optionally print/parse.
    *
    * This method has the same effect as appending each of the constituent parts directly to this
-   * builder surrounded by an {@link #optionalStart()} and {@link #optionalEnd()}.
+   * builder surrounded by an {@link #optionalStart()} and {@link #optionalEnd()} .
    *
    * The formatter will print if data is available for all the fields contained within it. The
    * formatter will parse if the string matches, otherwise no error is returned.
@@ -1235,10 +1236,9 @@ final class DateTimeFormatterBuilder private (
    *
    * All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters. The characters '{' and
    * '}' are reserved for future use. The characters '[' and ']' indicate optional patterns. The
-   * following pattern letters are defined: <pre> Symbol Meaning Presentation Examples
-   * ------ ------- ------------ ------- G era number/text 1; 01; AD; Anno Domini y year year 2004;
-   * 04 D day-of-year number 189 M month-of-year number/text 7; 07; Jul; July; J d day-of-month
-   * number 10
+   * following pattern letters are defined: <pre> Symbol Meaning Presentation Examples ------
+   * ------- ------------ ------- G era number/text 1; 01; AD; Anno Domini y year year 2004; 04 D
+   * day-of-year number 189 M month-of-year number/text 7; 07; Jul; July; J d day-of-month number 10
    *
    * Q quarter-of-year number/text 3; 03; Q3 Y week-based-year year 1996; 96 w week-of-year number
    * 27 W week-of-month number 27 e localized day-of-week number 2; Tue; Tuesday; T E day-of-week
@@ -1264,13 +1264,13 @@ final class DateTimeFormatterBuilder private (
    * The count of pattern letters determine the format.
    *
    * <b>Text</b>: The text style is determined based on the number of pattern letters used. Less
-   * than 4 pattern letters will use the {@link TextStyle#SHORT short form}. Exactly 4 pattern
-   * letters will use the {@link TextStyle#FULL full form}. Exactly 5 pattern letters will use the
-   * {@link TextStyle#NARROW narrow form}.
+   * than 4 pattern letters will use the {@link TextStyle#SHORT short form} . Exactly 4 pattern
+   * letters will use the {@link TextStyle#FULL full form} . Exactly 5 pattern letters will use the
+   * {@link TextStyle#NARROW narrow form} .
    *
    * <b>Number</b>: If the count of letters is one, then the value is printed using the minimum
-   * number of digits and without padding as per {@link #appendValue(TemporalField)}. Otherwise, the
-   * count of digits is used as the width of the output field as per {@link
+   * number of digits and without padding as per {@link #appendValue(TemporalField)} . Otherwise,
+   * the count of digits is used as the width of the output field as per {@link
    * #appendValue(TemporalField, int)}.
    *
    * <b>Number/Text</b>: If the count of pattern letters is 3 or greater, use the Text rules above.
@@ -1288,7 +1288,7 @@ final class DateTimeFormatterBuilder private (
    * is used. For printing, this outputs the rightmost two digits. For parsing, this will parse
    * using the base value of 2000, resulting in a year within the range 2000 to 2099 inclusive. If
    * the count of letters is less than four (but not two), then the sign is only output for negative
-   * years as per {@link SignStyle#NORMAL}. Otherwise, the sign is output if the pad width is
+   * years as per {@link SignStyle#NORMAL} . Otherwise, the sign is output if the pad width is
    * exceeded, as per {@link SignStyle#EXCEEDS_PAD}
    *
    * <b>ZoneId</b>: This outputs the time-zone ID, such as 'Europe/Paris'. If the count of letters
@@ -1297,7 +1297,7 @@ final class DateTimeFormatterBuilder private (
    *
    * <b>Zone names</b>: This outputs the display name of the time-zone ID. If the count of letters
    * is one, two or three, then the short name is output. If the count of letters is four, then the
-   * full name is output. Five or more letters throws {@code IllegalArgumentException}. <pre>
+   * full name is output. Five or more letters throws {@code IllegalArgumentException} . <pre>
    * Pattern Equivalent builder methods z appendZoneText(TextStyle.SHORT) zz
    * appendZoneText(TextStyle.SHORT) zzz appendZoneText(TextStyle.SHORT) zzzz
    * appendZoneText(TextStyle.FULL) </pre>
@@ -1308,27 +1308,27 @@ final class DateTimeFormatterBuilder private (
    * colon, such as '+0130'. Three letters outputs the hour and minute, with a colon, such as
    * '+01:30'. Four letters outputs the hour and minute and optional second, without a colon, such
    * as '+013015'. Five letters outputs the hour and minute and optional second, with a colon, such
-   * as '+01:30:15'. Six or more letters throws {@code IllegalArgumentException}. Pattern letter 'X'
-   * (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern letter
-   * 'x' (lower case) will output '+00', '+0000', or '+00:00'. <pre> Pattern Equivalent builder
-   * methods X appendOffset("+HHmm","Z") XX appendOffset("+HHMM","Z") XXX appendOffset("+HH:MM","Z")
-   * XXXX appendOffset("+HHMMss","Z") XXXXX appendOffset("+HH:MM:ss","Z") x
-   * appendOffset("+HHmm","+00") xx appendOffset("+HHMM","+0000") xxx
+   * as '+01:30:15'. Six or more letters throws {@code IllegalArgumentException} . Pattern letter
+   * 'X' (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern
+   * letter 'x' (lower case) will output '+00', '+0000', or '+00:00'. <pre> Pattern Equivalent
+   * builder methods X appendOffset("+HHmm","Z") XX appendOffset("+HHMM","Z") XXX
+   * appendOffset("+HH:MM","Z") XXXX appendOffset("+HHMMss","Z") XXXXX appendOffset("+HH:MM:ss","Z")
+   * x appendOffset("+HHmm","+00") xx appendOffset("+HHMM","+0000") xxx
    * appendOffset("+HH:MM","+00:00") xxxx appendOffset("+HHMMss","+0000") xxxxx
    * appendOffset("+HH:MM:ss","+00:00") </pre>
    *
    * <b>Offset Z</b>: This formats the offset based on the number of pattern letters. One, two or
    * three letters outputs the hour and minute, without a colon, such as '+0130'. Four or more
-   * letters throws {@code IllegalArgumentException}. The output will be '+0000' when the offset is
+   * letters throws {@code IllegalArgumentException} . The output will be '+0000' when the offset is
    * zero. <pre> Pattern Equivalent builder methods Z appendOffset("+HHMM","+0000") ZZ
    * appendOffset("+HHMM","+0000") ZZZ appendOffset("+HHMM","+0000") </pre>
    *
    * <b>Optional section</b>: The optional section markers work exactly like calling {@link
-   * #optionalStart()} and {@link #optionalEnd()}.
+   * #optionalStart()} and {@link #optionalEnd()} .
    *
    * <b>Pad modifier</b>: Modifies the pattern that immediately follows to be padded with spaces.
    * The pad width is determined by the number of pattern letters. This is the same as calling
-   * {@link #padNext(int)}.
+   * {@link #padNext(int)} .
    *
    * For example, 'ppH' outputs the hour-of-day padded on the left with spaces to a width of 2.
    *
@@ -1705,7 +1705,7 @@ final class DateTimeFormatterBuilder private (
    * @return
    *   this, for chaining, not null
    * @throws IllegalStateException
-   *   if there was no previous call to { @code optionalStart}
+   *   if there was no previous call to {@code optionalStart}
    */
   def optionalEnd(): DateTimeFormatterBuilder = {
     if (active.parent == null)
@@ -1759,7 +1759,7 @@ final class DateTimeFormatterBuilder private (
    * #optionalEnd()} before creating the formatter.
    *
    * This builder can still be used after creating the formatter if desired, although the state may
-   * have been changed by calls to {@code optionalEnd}.
+   * have been changed by calls to {@code optionalEnd} .
    *
    * @return
    *   the created formatter, not null
@@ -1776,7 +1776,7 @@ final class DateTimeFormatterBuilder private (
    * #optionalEnd()} before creating the formatter.
    *
    * This builder can still be used after creating the formatter if desired, although the state may
-   * have been changed by calls to {@code optionalEnd}.
+   * have been changed by calls to {@code optionalEnd} .
    *
    * @param locale
    *   the locale to use for formatting, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala b/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala
index 9c240e7e2..e50e2b175 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala
@@ -48,7 +48,7 @@ private object SimpleDateTimeFormatStyleProvider {
 /**
  * The Service Provider Implementation to obtain date-time formatters for a style.
  *
- * This implementation is based on extraction of data from a {@link SimpleDateFormat}.
+ * This implementation is based on extraction of data from a {@link SimpleDateFormat} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  */
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala b/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala
index 7b5cf17c3..3823599c0 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala
@@ -12,7 +12,7 @@ import java.lang.StringBuilder
  * Typically, each individual parser will just parse one field, such as the day-of-month, storing
  * the value in the context. Once the parse is complete, the caller will then convert the context to
  * a {@link DateTimeBuilder} to merge the parsed values to create the desired object, such as a
- * {@code LocalDate}.
+ * {@code LocalDate} .
  *
  * The parse position will be updated during the parse. Parsing will start at the specified index
  * and the return value specifies the new parse position for the next parser. If an error occurs,
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala
index e4e1cd950..76c39a6d7 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala
@@ -178,7 +178,7 @@ final class TTBPDateTimeParseContext(
   def setCaseSensitive(caseSensitive: Boolean): Unit = this.caseSensitive = caseSensitive
 
   /**
-   * Helper to compare two {@code CharSequence} instances. This uses {@link #isCaseSensitive()}.
+   * Helper to compare two {@code CharSequence} instances. This uses {@link #isCaseSensitive()} .
    *
    * @param cs1
    *   the first character sequence, not null
@@ -228,7 +228,7 @@ final class TTBPDateTimeParseContext(
   }
 
   /**
-   * Helper to compare two {@code char}. This uses {@link #isCaseSensitive()}.
+   * Helper to compare two {@code char} . This uses {@link #isCaseSensitive()} .
    *
    * @param ch1
    *   the first character
@@ -463,7 +463,7 @@ final class TTBPDateTimeParseContext(
      *
      * This method is typically used once parsing is complete to obtain the parsed data. Parsing
      * will typically result in separate fields, such as year, month and day. The returned builder
-     * can be used to combine the parsed data into meaningful objects such as {@code LocalDate},
+     * can be used to combine the parsed data into meaningful objects such as {@code LocalDate} ,
      * potentially applying complex processing to handle invalid parsed data.
      *
      * @return
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala
index ef645bee8..8578cc8bf 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala
@@ -133,7 +133,7 @@ object TTBPSimpleDateTimeTextProvider {
 /**
  * The Service Provider Implementation to obtain date-time text for a field.
  *
- * This implementation is based on extraction of data from a {@link DateFormatSymbols}.
+ * This implementation is based on extraction of data from a {@link DateFormatSymbols} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  */
diff --git a/core/shared/src/main/scala/org/threeten/bp/package.scala b/core/shared/src/main/scala/org/threeten/bp/package.scala
index d5fd8f3ce..1c8d3fb17 100644
--- a/core/shared/src/main/scala/org/threeten/bp/package.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/package.scala
@@ -53,7 +53,7 @@ package org.threeten
  * ==Dates and Times==
  *
  * {@link org.threeten.bp.Instant} is essentially a numeric timestamp. The current Instant can be
- * retrieved from a {@link org.threeten.bp.Clock}. This is useful for logging and persistence of a
+ * retrieved from a {@link org.threeten.bp.Clock} . This is useful for logging and persistence of a
  * point in time and has in the past been associated with storing the result from {@link
  * java.lang.System#currentTimeMillis()}.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala
index 37011c101..01f064496 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala
@@ -37,7 +37,7 @@ package org.threeten.bp.temporal
  *
  * This is the base interface type for date, time and offset objects that are complete enough to be
  * manipulated using plus and minus. It is implemented by those classes that can provide and
- * manipulate information as {@link TemporalField fields} or {@link TemporalQuery queries}. See
+ * manipulate information as {@link TemporalField fields} or {@link TemporalQuery queries} . See
  * {@link TemporalAccessor} for the read-only version of this interface.
  *
  * Most date and time information can be represented as a number. These are modeled using {@code
@@ -46,8 +46,8 @@ package org.threeten.bp.temporal
  * ChronoField} for the standard set of fields.
  *
  * Two pieces of date/time information cannot be represented by numbers, the {@link Chronology
- * chronology} and the {@link ZoneId time-zone}. These can be accessed via {@link
- * #query(TemporalQuery) queries} using the static methods defined on {@link TemporalQueries}.
+ * chronology} and the {@link ZoneId time-zone} . These can be accessed via {@link
+ * #query(TemporalQuery) queries} using the static methods defined on {@link TemporalQueries} .
  *
  * This interface is a framework-level interface that should not be widely used in application code.
  * Instead, applications should create and pass around instances of concrete types, such as {@code
@@ -78,7 +78,7 @@ package org.threeten.bp.temporal
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
  * of implementations, however immutability is strongly recommended. All implementations must be
- * {@link Comparable}.
+ * {@link Comparable} .
  */
 trait Temporal extends TemporalAccessor {
 
@@ -90,10 +90,10 @@ trait Temporal extends TemporalAccessor {
    * an exception.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoUnit}. If the field is supported, then true is returned, otherwise
+   * defined in {@link ChronoUnit} . If the field is supported, then true is returned, otherwise
    * false
    *
-   * If the field is not a {@code ChronoUnit}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoUnit} , then the result of this method is obtained by
    * invoking {@code TemporalUnit.isSupportedBy(Temporal)} passing {@code this} as the argument.
    *
    * Implementations must not alter this object.
@@ -111,7 +111,7 @@ trait Temporal extends TemporalAccessor {
    * This adjusts this date-time according to the rules of the specified adjuster. A simple adjuster
    * might simply set the one of the fields, such as the year field. A more complex adjuster might
    * set the date to the last day of the month. A selection of common adjustments is provided in
-   * {@link TemporalAdjusters}. These include finding the "last day of the month" and "next
+   * {@link TemporalAdjusters} . These include finding the "last day of the month" and "next
    * Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths
    * of month and leap years.
    *
@@ -139,8 +139,8 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with the specified field altered.
    *
    * This returns a new object based on this one with the value for the specified field changed. For
-   * example, on a {@code LocalDate}, this could be used to set the year, month or day-of-month. The
-   * returned object will have the same observable type as this object.
+   * example, on a {@code LocalDate} , this could be used to set the year, month or day-of-month.
+   * The returned object will have the same observable type as this object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
    * date representing the 31st January, then changing the month to February would be unclear. In
@@ -148,10 +148,10 @@ trait Temporal extends TemporalAccessor {
    * the previous valid date, which would be the last valid day of February in this example.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then the adjustment must be
+   * defined in {@link ChronoField} . If the field is supported, then the adjustment must be
    * performed. If unsupported, then a {@code DateTimeException} must be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the first
    * argument.
    *
@@ -177,7 +177,7 @@ trait Temporal extends TemporalAccessor {
    *
    * This adjusts this temporal, adding according to the rules of the specified amount. The amount
    * is typically a {@link Period} but may be any other type implementing the {@link TemporalAmount}
-   * interface, such as {@link Duration}.
+   * interface, such as {@link Duration} .
    *
    * Some example code indicating how and why this method is used: <pre> date = date.plus(period);
    * // add a Period instance date = date.plus(duration); // add a Duration instance date =
@@ -205,7 +205,7 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with the specified period added.
    *
    * This method returns a new object based on this one with the specified period added. For
-   * example, on a {@code LocalDate}, this could be used to add a number of years, months or days.
+   * example, on a {@code LocalDate} , this could be used to add a number of years, months or days.
    * The returned object will have the same observable type as this object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
@@ -213,17 +213,17 @@ trait Temporal extends TemporalAccessor {
    * the field is responsible for resolving the result. Typically it will choose the previous valid
    * date, which would be the last valid day of February in this example.
    *
-   * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
+   * If the implementation represents a date-time that has boundaries, such as {@code LocalTime} ,
    * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
    * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code
    * MONTHS}.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all units defined
-   * in {@link ChronoUnit}. If the unit is supported, then the addition must be performed. If
+   * in {@link ChronoUnit} . If the unit is supported, then the addition must be performed. If
    * unsupported, then a {@code DateTimeException} must be thrown.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.addTo(Temporal, long)} passing {@code this} as the first argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.addTo(Temporal, long)} passing {@code this} as the first argument.
    *
    * Implementations must not alter either this object or the specified temporal object. Instead, an
    * adjusted copy of the original must be returned. This provides equivalent, safe behavior for
@@ -247,7 +247,7 @@ trait Temporal extends TemporalAccessor {
    *
    * This adjusts this temporal, subtracting according to the rules of the specified amount. The
    * amount is typically a {@link Period} but may be any other type implementing the {@link
-   * TemporalAmount} interface, such as {@link Duration}.
+   * TemporalAmount} interface, such as {@link Duration} .
    *
    * Some example code indicating how and why this method is used: <pre> date = date.minus(period);
    * // subtract a Period instance date = date.minus(duration); // subtract a Duration instance date
@@ -275,7 +275,7 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with the specified period subtracted.
    *
    * This method returns a new object based on this one with the specified period subtracted. For
-   * example, on a {@code LocalDate}, this could be used to subtract a number of years, months or
+   * example, on a {@code LocalDate} , this could be used to subtract a number of years, months or
    * days. The returned object will have the same observable type as this object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
@@ -283,7 +283,7 @@ trait Temporal extends TemporalAccessor {
    * this, the field is responsible for resolving the result. Typically it will choose the previous
    * valid date, which would be the last valid day of February in this example.
    *
-   * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
+   * If the implementation represents a date-time that has boundaries, such as {@code LocalTime} ,
    * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
    * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code
    * MONTHS}.
@@ -317,16 +317,17 @@ trait Temporal extends TemporalAccessor {
    * This calculates the period between two temporals in terms of a single unit. The start and end
    * points are {@code this} and the specified temporal. The result will be negative if the end is
    * before the start. For example, the period in hours between two temporal objects can be
-   * calculated using {@code startTime.until(endTime, HOURS)}.
+   * calculated using {@code startTime.until(endTime, HOURS)} .
    *
    * The calculation returns a whole number, representing the number of complete units between the
    * two temporals. For example, the period in hours between the times 11:30 and 13:29 will only be
    * one hour as it is one minute short of two hours.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: <pre> // these
-   * two lines are equivalent between = thisUnit.between(start, end); between = start.until(end,
-   * thisUnit); </pre> The choice should be made based on which makes the code more readable.
+   * directly. The second is to use {@link TemporalUnit#between(Temporal, Temporal)} : <pre> //
+   * these two lines are equivalent between = thisUnit.between(start, end); between =
+   * start.until(end, thisUnit); </pre> The choice should be made based on which makes the code more
+   * readable.
    *
    * For example, this method allows the number of days between two dates to be calculated: <pre>
    * val daysBetween: Long = DAYS.between(start, end); // or alternatively val daysBetween: Long =
@@ -334,12 +335,12 @@ trait Temporal extends TemporalAccessor {
    *
    * <h3>Specification for implementors</h3> Implementations must begin by checking to ensure that
    * the input temporal object is of the same observable type as the implementation. They must then
-   * perform the calculation for all instances of {@link ChronoUnit}. A {@code DateTimeException}
+   * perform the calculation for all instances of {@link ChronoUnit} . A {@code DateTimeException}
    * must be thrown for {@code ChronoUnit} instances that are unsupported.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@code ChronoUnit} , then the result of this method is obtained by
+   * invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first
+   * argument and the input temporal as the second argument.
    *
    * In summary, implementations must behave in a manner equivalent to this code: <pre> // check
    * input temporal is the same type as this class if (unit instanceof ChronoUnit) { // if unit is
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala
index 5d3791093..0d5017f97 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala
@@ -45,10 +45,10 @@ package org.threeten.bp.temporal
  * ChronoField} for the standard set of fields.
  *
  * Two pieces of date/time information cannot be represented by numbers, the {@link Chronology
- * chronology} and the {@link ZoneId time-zone}. These can be accessed via {@link
- * #query(TemporalQuery) queries} using the static methods defined on {@link TemporalQueries}.
+ * chronology} and the {@link ZoneId time-zone} . These can be accessed via {@link
+ * #query(TemporalQuery) queries} using the static methods defined on {@link TemporalQueries} .
  *
- * A sub-interface, {@link Temporal}, extends this definition to one that also supports adjustment
+ * A sub-interface, {@link Temporal} , extends this definition to one that also supports adjustment
  * and manipulation on more complete temporal objects.
  *
  * This interface is a framework-level interface that should not be widely used in application code.
@@ -70,10 +70,10 @@ trait TemporalAccessor {
    * exception.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then true is returned, otherwise
+   * defined in {@link ChronoField} . If the field is supported, then true is returned, otherwise
    * false
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
    * argument.
    *
@@ -99,10 +99,10 @@ trait TemporalAccessor {
    * invalid for the field.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then the range of the field must be
+   * defined in {@link ChronoField} . If the field is supported, then the range of the field must be
    * returned. If unsupported, then a {@code DateTimeException} must be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessorl)} passing {@code this} as the
    * argument.
    *
@@ -123,18 +123,18 @@ trait TemporalAccessor {
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field as an {@code int}.
+   * Gets the value of the specified field as an {@code int} .
    *
    * This queries the date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If the date-time cannot return the
    * value, because the field is unsupported or for some other reason, an exception will be thrown.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported and has an {@code int} range, then
+   * defined in {@link ChronoField} . If the field is supported and has an {@code int} range, then
    * the value of the field must be returned. If unsupported, then a {@code DateTimeException} must
    * be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    *
    * Implementations must not alter either this object.
@@ -146,7 +146,7 @@ trait TemporalAccessor {
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@code int}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -155,17 +155,17 @@ trait TemporalAccessor {
   def get(field: TemporalField): Int = range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field as a {@code long}.
+   * Gets the value of the specified field as a {@code long} .
    *
    * This queries the date-time for the value for the specified field. The returned value may be
    * outside the valid range of values for the field. If the date-time cannot return the value,
    * because the field is unsupported or for some other reason, an exception will be thrown.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then the value of the field must be
+   * defined in {@link ChronoField} . If the field is supported, then the value of the field must be
    * returned. If unsupported, then a {@code DateTimeException} must be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
+   * If the field is not a {@code ChronoField} , then the result of this method is obtained by
    * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
    *
    * Implementations must not alter either this object.
@@ -192,7 +192,7 @@ trait TemporalAccessor {
    * year, or calculates the number of days to your next birthday.
    *
    * The most common query implementations are method references, such as {@code LocalDate::from}
-   * and {@code ZoneId::from}. Further implementations are on {@link TemporalQueries}. Queries may
+   * and {@code ZoneId::from} . Further implementations are on {@link TemporalQueries} . Queries may
    * also be defined by applications.
    *
    * <h3>Specification for implementors</h3> Implementations of this method must behave as follows:
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala
index c9ef184d2..7bd49f642 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala
@@ -39,12 +39,12 @@ package org.threeten.bp.temporal
  * be an adjuster that sets the date avoiding weekends, or one that sets the date to the last day of
  * the month.
  *
- * There are two equivalent ways of using a {@code TemporalAdjuster}. The first is to invoke the
- * method on this interface directly. The second is to use {@link Temporal#with(TemporalAdjuster)}:
+ * There are two equivalent ways of using a {@code TemporalAdjuster} . The first is to invoke the
+ * method on this interface directly. The second is to use {@link Temporal#with(TemporalAdjuster)} :
  * <pre> // these two lines are equivalent, but the second approach is recommended temporal =
  * thisAdjuster.adjustInto(temporal); temporal = temporal.with(thisAdjuster); </pre> It is
- * recommended to use the second approach, {@code with(TemporalAdjuster)}, as it is a lot clearer to
- * read in code.
+ * recommended to use the second approach, {@code with(TemporalAdjuster)} , as it is a lot clearer
+ * to read in code.
  *
  * See {@link TemporalAdjusters} for a standard set of adjusters, including finding the last day of
  * the month. Adjusters may also be defined by applications.
@@ -62,10 +62,10 @@ trait TemporalAdjuster {
    * date to the last day of the month.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#with(TemporalAdjuster)}: <pre> // these two
+   * directly. The second is to use {@link Temporal#with(TemporalAdjuster)} : <pre> // these two
    * lines are equivalent, but the second approach is recommended temporal =
    * thisAdjuster.adjustInto(temporal); temporal = temporal.with(thisAdjuster); </pre> It is
-   * recommended to use the second approach, {@code with(TemporalAdjuster)}, as it is a lot clearer
+   * recommended to use the second approach, {@code with(TemporalAdjuster)} , as it is a lot clearer
    * to read in code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and
@@ -79,7 +79,7 @@ trait TemporalAdjuster {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@link TemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala
index 8c0e4fb28..fc097e43a 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala
@@ -42,16 +42,16 @@ import org.threeten.bp.LocalDate
 import org.threeten.bp.DayOfWeek
 
 /**
- * Common implementations of {@code TemporalAdjuster}.
+ * Common implementations of {@code TemporalAdjuster} .
  *
- * This class provides common implementations of {@link TemporalAdjuster}. They are especially
+ * This class provides common implementations of {@link TemporalAdjuster} . They are especially
  * useful to document the intent of business logic and often link well to requirements. For example,
  * these two pieces of code do the same thing, but the second one is clearer (assuming that there is
  * a static import of this class): <pre> // direct manipulation
  * date.withDayOfMonth(1).plusMonths(1).minusDays(1); // use of an adjuster from this class
  * date.with(lastDayOfMonth()); </pre> There are two equivalent ways of using a {@code
  * TemporalAdjuster}. The first is to invoke the method on the interface directly. The second is to
- * use {@link Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the
+ * use {@link Temporal#with(TemporalAdjuster)} : <pre> // these two lines are equivalent, but the
  * second approach is recommended dateTime = adjuster.adjustInto(dateTime); dateTime =
  * dateTime.with(adjuster); </pre> It is recommended to use the second approach, {@code
  * with(TemporalAdjuster)}, as it is a lot clearer to read in code.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala
index 930784614..859386476 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala
@@ -39,7 +39,7 @@ package org.threeten.bp.temporal
  * time-of-day in that it is not tied to any specific point on the time-line.
  *
  * The amount can be thought of as a Map of {@code TemporalUnit} to long, exposed via {@link
- * #getUnits()} and {@link #get(TemporalUnit)}. A simple case might have a single unit-value pair,
+ * #getUnits()} and {@link #get(TemporalUnit)} . A simple case might have a single unit-value pair,
  * such as "6 hours". A more complex case may have multiple unit-value pairs, such as "7 years, 3
  * months and 5 days".
  *
@@ -50,7 +50,7 @@ package org.threeten.bp.temporal
  *
  * This interface is a framework-level interface that should not be widely used in application code.
  * Instead, applications should create and pass around instances of concrete types, such as {@code
- * Period} and {@code Duration}.
+ * Period} and {@code Duration} .
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
  * of implementations, however immutability is strongly recommended.
@@ -84,7 +84,7 @@ trait TemporalAmount {
    * class.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#plus(TemporalAmount)}: <pre> // these two lines
+   * directly. The second is to use {@link Temporal#plus(TemporalAmount)} : <pre> // these two lines
    * are equivalent, but the second approach is recommended dateTime = amount.addTo(dateTime);
    * dateTime = dateTime.plus(amount); </pre> It is recommended to use the second approach, {@code
    * plus(TemporalAmount)}, as it is a lot clearer to read in code.
@@ -99,7 +99,7 @@ trait TemporalAmount {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@link TemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
@@ -122,10 +122,11 @@ trait TemporalAmount {
    * class.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#minus(TemporalAmount)}: <pre> // these two lines
-   * are equivalent, but the second approach is recommended dateTime =
+   * directly. The second is to use {@link Temporal#minus(TemporalAmount)} : <pre> // these two
+   * lines are equivalent, but the second approach is recommended dateTime =
    * amount.subtractFrom(dateTime); dateTime = dateTime.minus(amount); </pre> It is recommended to
-   * use the second approach, {@code minus(TemporalAmount)}, as it is a lot clearer to read in code.
+   * use the second approach, {@code minus(TemporalAmount)} , as it is a lot clearer to read in
+   * code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and
    * subtract from it. The implementation defines the logic of the subtraction and is responsible
@@ -138,7 +139,7 @@ trait TemporalAmount {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@link TemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala
index a88843563..46b6e2d12 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala
@@ -40,12 +40,12 @@ import org.threeten.bp.format.ResolverStyle
  * Date and time is expressed using fields which partition the time-line into something meaningful
  * for humans. Implementations of this interface represent those fields.
  *
- * The most commonly used units are defined in {@link ChronoField}. Further fields are supplied in
- * {@link IsoFields}, {@link WeekFields} and {@link JulianFields}. Fields can also be written by
+ * The most commonly used units are defined in {@link ChronoField} . Further fields are supplied in
+ * {@link IsoFields} , {@link WeekFields} and {@link JulianFields} . Fields can also be written by
  * application code by implementing this interface.
  *
  * The field works using double dispatch. Client code calls methods on a date-time like {@code
- * LocalDateTime} which check if the field is a {@code ChronoField}. If it is, then the date-time
+ * LocalDateTime} which check if the field is a {@code ChronoField} . If it is, then the date-time
  * must handle it. Otherwise, the method call is re-dispatched to the matching method in this
  * interface.
  *
@@ -60,7 +60,7 @@ trait TemporalField {
    * Gets the unit that the field is measured in.
    *
    * The unit of the field is the period that varies within the range. For example, in the field
-   * 'MonthOfYear', the unit is 'Months'. See also {@link #getRangeUnit()}.
+   * 'MonthOfYear', the unit is 'Months'. See also {@link #getRangeUnit()} .
    *
    * @return
    *   the period unit defining the base unit of the field, not null
@@ -71,7 +71,7 @@ trait TemporalField {
    * Gets the range that the field is bound by.
    *
    * The range of the field is the period that the field varies within. For example, in the field
-   * 'MonthOfYear', the range is 'Years'. See also {@link #getBaseUnit()}.
+   * 'MonthOfYear', the range is 'Years'. See also {@link #getBaseUnit()} .
    *
    * The range is never null. For example, the 'Year' field is shorthand for 'YearOfForever'. It
    * therefore has a unit of 'Years' and a range of 'Forever'.
@@ -124,14 +124,14 @@ trait TemporalField {
    * the temporal cannot be queried for this field.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#isSupported(TemporalField)}: <pre> //
+   * directly. The second is to use {@link TemporalAccessor#isSupported(TemporalField)} : <pre> //
    * these two lines are equivalent, but the second approach is recommended temporal =
    * thisField.isSupportedBy(temporal); temporal = temporal.isSupported(thisField); </pre> It is
-   * recommended to use the second approach, {@code isSupported(TemporalField)}, as it is a lot
+   * recommended to use the second approach, {@code isSupported(TemporalField)} , as it is a lot
    * clearer to read in code.
    *
    * Implementations should determine whether they are supported using the fields available in
-   * {@link ChronoField}.
+   * {@link ChronoField} .
    *
    * @param temporal
    *   the temporal object to query, not null
@@ -144,17 +144,17 @@ trait TemporalField {
    * Get the range of valid values for this field using the temporal object to refine the result.
    *
    * This uses the temporal object to find the range of valid values for the field. This is similar
-   * to {@link #range()}, however this method refines the result using the temporal. For example, if
-   * the field is {@code DAY_OF_MONTH} the {@code range} method is not accurate as there are four
+   * to {@link #range()} , however this method refines the result using the temporal. For example,
+   * if the field is {@code DAY_OF_MONTH} the {@code range} method is not accurate as there are four
    * possible month lengths, 28, 29, 30 and 31 days. Using this method with a date allows the range
    * to be accurate, returning just one of those four options.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#range(TemporalField)}: <pre> // these
+   * directly. The second is to use {@link TemporalAccessor#range(TemporalField)} : <pre> // these
    * two lines are equivalent, but the second approach is recommended temporal =
    * thisField.rangeRefinedBy(temporal); temporal = temporal.range(thisField); </pre> It is
-   * recommended to use the second approach, {@code range(TemporalField)}, as it is a lot clearer to
-   * read in code.
+   * recommended to use the second approach, {@code range(TemporalField)} , as it is a lot clearer
+   * to read in code.
    *
    * Implementations should perform any queries or calculations using the fields available in {@link
    * ChronoField}. If the field is not supported a {@code DateTimeException} must be thrown.
@@ -197,7 +197,7 @@ trait TemporalField {
    *
    * If there is no display name for the locale then a suitable default must be returned.
    *
-   * The default implementation must check the locale is not null and return {@code toString()}.
+   * The default implementation must check the locale is not null and return {@code toString()} .
    *
    * @param locale
    *   the locale to use, not null
@@ -210,7 +210,7 @@ trait TemporalField {
    * Returns a copy of the specified temporal object with the value of this field set.
    *
    * This returns a new temporal object based on the specified one with the value for this field
-   * changed. For example, on a {@code LocalDate}, this could be used to set the year, month or
+   * changed. For example, on a {@code LocalDate} , this could be used to set the year, month or
    * day-of-month. The returned object has the same observable type as the specified object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
@@ -219,10 +219,10 @@ trait TemporalField {
    * choose the previous valid date, which would be the last valid day of February in this example.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#with(TemporalField, long)}: <pre> // these two
+   * directly. The second is to use {@link Temporal#with(TemporalField, long)} : <pre> // these two
    * lines are equivalent, but the second approach is recommended temporal =
    * thisField.adjustInto(temporal); temporal = temporal.with(thisField); </pre> It is recommended
-   * to use the second approach, {@code with(TemporalField)}, as it is a lot clearer to read in
+   * to use the second approach, {@code with(TemporalField)} , as it is a lot clearer to read in
    * code.
    *
    * Implementations should perform any queries or calculations using the fields available in {@link
@@ -249,7 +249,7 @@ trait TemporalField {
    * Resolves the date/time information in the builder
    *
    * This method is invoked during the resolve of the builder. Implementations should combine the
-   * associated field with others to form objects like {@code LocalDate}, {@code LocalTime} and
+   * associated field with others to form objects like {@code LocalDate} , {@code LocalTime} and
    * {@code LocalDateTime}
    *
    * @param fieldValues
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala
index a301cc11d..338b0cccb 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala
@@ -41,19 +41,20 @@ import org.threeten.bp.ZoneOffset
 import org.threeten.bp.chrono.Chronology
 
 /**
- * Common implementations of {@code TemporalQuery}.
+ * Common implementations of {@code TemporalQuery} .
  *
- * This class provides common implementations of {@link TemporalQuery}. These queries are primarily
+ * This class provides common implementations of {@link TemporalQuery} . These queries are primarily
  * used as optimizations, allowing the internals of other objects to be extracted effectively. Note
  * that application code can also use the {@code from(TemporalAccessor)} method on most temporal
  * objects as a method reference matching the query interface, such as {@code LocalDate::from} and
- * {@code ZoneId::from}.
+ * {@code ZoneId::from} .
  *
- * There are two equivalent ways of using a {@code TemporalQuery}. The first is to invoke the method
- * on the interface directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)}:
- * <pre> // these two lines are equivalent, but the second approach is recommended dateTime =
- * query.queryFrom(dateTime); dateTime = dateTime.query(query); </pre> It is recommended to use the
- * second approach, {@code query(TemporalQuery)}, as it is a lot clearer to read in code.
+ * There are two equivalent ways of using a {@code TemporalQuery} . The first is to invoke the
+ * method on the interface directly. The second is to use
+ * {@link TemporalAccessor#query(TemporalQuery)} : <pre> // these two lines are equivalent, but the
+ * second approach is recommended dateTime = query.queryFrom(dateTime); dateTime =
+ * dateTime.query(query); </pre> It is recommended to use the second approach,
+ * {@code query(TemporalQuery)} , as it is a lot clearer to read in code.
  *
  * <h3>Specification for implementors</h3> This is a thread-safe utility class. All returned
  * adjusters are immutable and thread-safe.
@@ -61,12 +62,12 @@ import org.threeten.bp.chrono.Chronology
 object TemporalQueries {
 
   /**
-   * A strict query for the {@code ZoneId}.
+   * A strict query for the {@code ZoneId} .
    *
    * This queries a {@code TemporalAccessor} for the zone. The zone is only returned if the
-   * date-time conceptually contains a {@code ZoneId}. It will not be returned if the date-time only
-   * conceptually has an {@code ZoneOffset}. Thus a {@link ZonedDateTime} will return the result of
-   * {@code getZone()}, but an {@link OffsetDateTime} will return null.
+   * date-time conceptually contains a {@code ZoneId} . It will not be returned if the date-time
+   * only conceptually has an {@code ZoneOffset} . Thus a {@link ZonedDateTime} will return the
+   * result of {@code getZone()} , but an {@link OffsetDateTime} will return null.
    *
    * In most cases, applications should use {@link #ZONE} as this query is too strict.
    *
@@ -87,29 +88,29 @@ object TemporalQueries {
   }
 
   /**
-   * A query for the {@code Chronology}.
+   * A query for the {@code Chronology} .
    *
    * This queries a {@code TemporalAccessor} for the chronology. If the target {@code
    * TemporalAccessor} represents a date, or part of a date, then it should return the chronology
    * that the date is expressed in. As a result of this definition, objects only representing time,
-   * such as {@code LocalTime}, will return null.
+   * such as {@code LocalTime} , will return null.
    *
    * The result from JDK classes implementing {@code TemporalAccessor} is as follows:<br> {@code
-   * LocalDate} returns {@code IsoChronology.INSTANCE}<br> {@code LocalTime} returns null (does not
-   * represent a date)<br> {@code LocalDateTime} returns {@code IsoChronology.INSTANCE}<br> {@code
-   * ZonedDateTime} returns {@code IsoChronology.INSTANCE}<br> {@code OffsetTime} returns null (does
-   * not represent a date)<br> {@code OffsetDateTime} returns {@code IsoChronology.INSTANCE}<br>
-   * {@code ChronoLocalDate} returns the associated chronology<br> {@code ChronoLocalDateTime}
+   * LocalDate} returns {@code IsoChronology.INSTANCE} <br> {@code LocalTime} returns null (does not
+   * represent a date)<br> {@code LocalDateTime} returns {@code IsoChronology.INSTANCE} <br> {@code
+   * ZonedDateTime} returns {@code IsoChronology.INSTANCE} <br> {@code OffsetTime} returns null
+   * (does not represent a date)<br> {@code OffsetDateTime} returns {@code IsoChronology.INSTANCE}
+   * <br> {@code ChronoLocalDate} returns the associated chronology<br> {@code ChronoLocalDateTime}
    * returns the associated chronology<br> {@code ChronoZonedDateTime} returns the associated
    * chronology<br> {@code Era} returns the associated chronology<br> {@code DayOfWeek} returns null
-   * (shared across chronologies)<br> {@code Month} returns {@code IsoChronology.INSTANCE}<br>
-   * {@code Year} returns {@code IsoChronology.INSTANCE}<br> {@code YearMonth} returns {@code
-   * IsoChronology.INSTANCE}<br> {@code MonthDay} returns null {@code IsoChronology.INSTANCE}<br>
+   * (shared across chronologies)<br> {@code Month} returns {@code IsoChronology.INSTANCE} <br>
+   * {@code Year} returns {@code IsoChronology.INSTANCE} <br> {@code YearMonth} returns {@code
+   * IsoChronology.INSTANCE}<br> {@code MonthDay} returns null {@code IsoChronology.INSTANCE} <br>
    * {@code ZoneOffset} returns null (does not represent a date)<br> {@code Instant} returns null
    * (does not represent a date)<br>
    *
    * The method {@link Chronology#from(TemporalAccessor)} can be used as a {@code TemporalQuery} via
-   * a method reference, {@code Chrono::from}. That method is equivalent to this query, except that
+   * a method reference, {@code Chrono::from} . That method is equivalent to this query, except that
    * it throws an exception if a chronology cannot be obtained.
    *
    * @return
@@ -131,15 +132,16 @@ object TemporalQueries {
    * MILLIS}.
    *
    * The result from JDK classes implementing {@code TemporalAccessor} is as follows:<br> {@code
-   * LocalDate} returns {@code DAYS}<br> {@code LocalTime} returns {@code NANOS}<br> {@code
-   * LocalDateTime} returns {@code NANOS}<br> {@code ZonedDateTime} returns {@code NANOS}<br> {@code
-   * OffsetTime} returns {@code NANOS}<br> {@code OffsetDateTime} returns {@code NANOS}<br> {@code
-   * ChronoLocalDate} returns {@code DAYS}<br> {@code ChronoLocalDateTime} returns {@code NANOS}<br>
-   * {@code ChronoZonedDateTime} returns {@code NANOS}<br> {@code Era} returns {@code ERAS}<br>
-   * {@code DayOfWeek} returns {@code DAYS}<br> {@code Month} returns {@code MONTHS}<br> {@code
-   * Year} returns {@code YEARS}<br> {@code YearMonth} returns {@code MONTHS}<br> {@code MonthDay}
-   * returns null (does not represent a complete date or time)<br> {@code ZoneOffset} returns null
-   * (does not represent a date or time)<br> {@code Instant} returns {@code NANOS}<br>
+   * LocalDate} returns {@code DAYS} <br> {@code LocalTime} returns {@code NANOS} <br> {@code
+   * LocalDateTime} returns {@code NANOS} <br> {@code ZonedDateTime} returns {@code NANOS} <br>
+   * {@code OffsetTime} returns {@code NANOS} <br> {@code OffsetDateTime} returns {@code NANOS} <br>
+   * {@code ChronoLocalDate} returns {@code DAYS} <br> {@code ChronoLocalDateTime} returns
+   * {@code NANOS} <br> {@code ChronoZonedDateTime} returns {@code NANOS} <br> {@code Era} returns
+   * {@code ERAS} <br> {@code DayOfWeek} returns {@code DAYS} <br> {@code Month} returns
+   * {@code MONTHS} <br> {@code Year} returns {@code YEARS} <br> {@code YearMonth} returns
+   * {@code MONTHS} <br> {@code MonthDay} returns null (does not represent a complete date or
+   * time)<br> {@code ZoneOffset} returns null (does not represent a date or time)<br>
+   * {@code Instant} returns {@code NANOS} <br>
    *
    * @return
    *   a query that can obtain the precision of a temporal, not null
@@ -155,7 +157,7 @@ object TemporalQueries {
    * offset. The query will return null if the temporal object cannot supply an offset.
    *
    * The query implementation examines the {@link ChronoField#OFFSET_SECONDS OFFSET_SECONDS} field
-   * and uses it to create a {@code ZoneOffset}.
+   * and uses it to create a {@code ZoneOffset} .
    *
    * @return
    *   a query that can obtain the offset of a temporal, not null
@@ -168,19 +170,19 @@ object TemporalQueries {
   }
 
   /**
-   * A lenient query for the {@code ZoneId}, falling back to the {@code ZoneOffset}.
+   * A lenient query for the {@code ZoneId} , falling back to the {@code ZoneOffset} .
    *
    * This queries a {@code TemporalAccessor} for the zone. It first tries to obtain the zone, using
-   * {@link #zoneId()}. If that is not found it tries to obtain the {@link #offset()}.
+   * {@link #zoneId()} . If that is not found it tries to obtain the {@link #offset()} .
    *
-   * In most cases, applications should use this query rather than {@code #zoneId()}.
+   * In most cases, applications should use this query rather than {@code #zoneId()} .
    *
    * This query examines the {@link ChronoField#OFFSET_SECONDS offset-seconds} field and uses it to
-   * create a {@code ZoneOffset}.
+   * create a {@code ZoneOffset} .
    *
    * The method {@link ZoneId#from(TemporalAccessor)} can be used as a {@code TemporalQuery} via a
-   * method reference, {@code ZoneId::from}. That method is equivalent to this query, except that it
-   * throws an exception if a zone cannot be obtained.
+   * method reference, {@code ZoneId::from} . That method is equivalent to this query, except that
+   * it throws an exception if a zone cannot be obtained.
    *
    * @return
    *   a query that can obtain the zone ID or offset of a temporal, not null
@@ -199,7 +201,7 @@ object TemporalQueries {
    * date. The query will return null if the temporal object cannot supply a local date.
    *
    * The query implementation examines the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field and uses it
-   * to create a {@code LocalDate}.
+   * to create a {@code LocalDate} .
    *
    * @return
    *   a query that can obtain the date of a temporal, not null
@@ -217,7 +219,7 @@ object TemporalQueries {
    * time. The query will return null if the temporal object cannot supply a local time.
    *
    * The query implementation examines the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY} field and
-   * uses it to create a {@code LocalTime}.
+   * uses it to create a {@code LocalTime} .
    *
    * @return
    *   a query that can obtain the date of a temporal, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala
index b31046027..14b4afe89 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala
@@ -40,16 +40,17 @@ package org.threeten.bp.temporal
  * leap year, or calculates the number of days to your next birthday.
  *
  * The {@link TemporalField} interface provides another mechanism for querying temporal objects.
- * That interface is limited to returning a {@code long}. By contrast, queries can return any type.
+ * That interface is limited to returning a {@code long} . By contrast, queries can return any type.
  *
- * There are two equivalent ways of using a {@code TemporalQuery}. The first is to invoke the method
- * on this interface directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)}:
- * <pre> // these two lines are equivalent, but the second approach is recommended temporal =
- * thisQuery.queryFrom(temporal); temporal = temporal.query(thisQuery); </pre> It is recommended to
- * use the second approach, {@code query(TemporalQuery)}, as it is a lot clearer to read in code.
+ * There are two equivalent ways of using a {@code TemporalQuery} . The first is to invoke the
+ * method on this interface directly. The second is to use
+ * {@link TemporalAccessor#query(TemporalQuery)} : <pre> // these two lines are equivalent, but the
+ * second approach is recommended temporal = thisQuery.queryFrom(temporal); temporal =
+ * temporal.query(thisQuery); </pre> It is recommended to use the second approach,
+ * {@code query(TemporalQuery)} , as it is a lot clearer to read in code.
  *
  * The most common implementations are method references, such as {@code LocalDate::from} and {@code
- * ZoneId::from}. Further implementations are on {@link TemporalQueries}. Queries may also be
+ * ZoneId::from}. Further implementations are on {@link TemporalQueries} . Queries may also be
  * defined by applications.
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
@@ -65,10 +66,10 @@ trait TemporalQuery[+R] {
    * February 29th in a leap year, or calculates the number of days to your next birthday.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)}: <pre> // these
+   * directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)} : <pre> // these
    * two lines are equivalent, but the second approach is recommended temporal =
    * thisQuery.queryFrom(temporal); temporal = temporal.query(thisQuery); </pre> It is recommended
-   * to use the second approach, {@code query(TemporalQuery)}, as it is a lot clearer to read in
+   * to use the second approach, {@code query(TemporalQuery)} , as it is a lot clearer to read in
    * code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and query
@@ -78,7 +79,7 @@ trait TemporalQuery[+R] {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@link TemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala
index f7cd1668d..f15e75d94 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala
@@ -42,12 +42,13 @@ import org.threeten.bp.Duration
  * An instance of this interface represents the unit itself, rather than an amount of the unit. See
  * {@link Period} for a class that represents an amount in terms of the common units.
  *
- * The most commonly used units are defined in {@link ChronoUnit}. Further units are supplied in
- * {@link IsoFields}. Units can also be written by application code by implementing this interface.
+ * The most commonly used units are defined in {@link ChronoUnit} . Further units are supplied in
+ * {@link IsoFields} . Units can also be written by application code by implementing this interface.
  *
  * The unit works using double dispatch. Client code calls methods on a date-time like {@code
- * LocalDateTime} which check if the unit is a {@code ChronoUnit}. If it is, then the date-time must
- * handle it. Otherwise, the method call is re-dispatched to the matching method in this interface.
+ * LocalDateTime} which check if the unit is a {@code ChronoUnit} . If it is, then the date-time
+ * must handle it. Otherwise, the method call is re-dispatched to the matching method in this
+ * interface.
  *
  * <h3>Specification for implementors</h3> This interface must be implemented with care to ensure
  * other classes operate correctly. All implementations that can be instantiated must be final,
@@ -64,7 +65,7 @@ trait TemporalUnit {
    *
    * Some units may return an accurate duration while others return an estimate. For example, days
    * have an estimated duration due to the possibility of daylight saving time changes. To determine
-   * if the duration is an estimate, use {@link #isDurationEstimated()}.
+   * if the duration is an estimate, use {@link #isDurationEstimated()} .
    *
    * @return
    *   the duration of this unit, which may be an estimate, not null
@@ -121,13 +122,13 @@ trait TemporalUnit {
    * and the period "3". The period to be added may be negative, which is equivalent to subtraction.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#plus(long, TemporalUnit)}: <pre> // these two
+   * directly. The second is to use {@link Temporal#plus(long, TemporalUnit)} : <pre> // these two
    * lines are equivalent, but the second approach is recommended temporal =
    * thisUnit.doPlus(temporal); temporal = temporal.plus(thisUnit); </pre> It is recommended to use
-   * the second approach, {@code plus(TemporalUnit)}, as it is a lot clearer to read in code.
+   * the second approach, {@code plus(TemporalUnit)} , as it is a lot clearer to read in code.
    *
    * Implementations should perform any queries or calculations using the units available in {@link
-   * ChronoUnit} or the fields available in {@link ChronoField}. If the field is not supported a
+   * ChronoUnit} or the fields available in {@link ChronoField} . If the field is not supported a
    * {@code DateTimeException} must be thrown.
    *
    * Implementations must not alter the specified temporal object. Instead, an adjusted copy of the
@@ -153,21 +154,21 @@ trait TemporalUnit {
    * This calculates the period between two temporals in terms of this unit. The start and end
    * points are supplied as temporal objects and must be of the same type. The result will be
    * negative if the end is before the start. For example, the period in hours between two temporal
-   * objects can be calculated using {@code HOURS.between(startTime, endTime)}.
+   * objects can be calculated using {@code HOURS.between(startTime, endTime)} .
    *
    * The calculation returns a whole number, representing the number of complete units between the
    * two temporals. For example, the period in hours between the times 11:30 and 13:29 will only b
    * one hour as it is one minute short of two hours.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#until(Temporal, TemporalUnit)}: <pre> // these
+   * directly. The second is to use {@link Temporal#until(Temporal, TemporalUnit)} : <pre> // these
    * two lines are equivalent between = thisUnit.between(start, end); between = start.until(end,
    * thisUnit); </pre> The choice should be made based on which makes the code more readable.
    *
    * For example, this method allows the number of days between two dates to be calculated: <pre>
    * long daysBetween = DAYS.between(start, end); // or alternatively long daysBetween =
    * start.until(end, DAYS); </pre> Implementations should perform any queries or calculations using
-   * the units available in {@link ChronoUnit} or the fields available in {@link ChronoField}. If
+   * the units available in {@link ChronoUnit} or the fields available in {@link ChronoField} . If
    * the unit is not supported a DateTimeException must be thrown. Implementations must not alter
    * the specified temporal objects.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala
index 826ee97c1..fbc596421 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala
@@ -199,18 +199,18 @@ final class ValueRange private (
   def getMaximum: Long = maxLargest
 
   /**
-   * Checks if all values in the range fit in an {@code int}.
+   * Checks if all values in the range fit in an {@code int} .
    *
-   * This checks that all valid values are within the bounds of an {@code int}.
+   * This checks that all valid values are within the bounds of an {@code int} .
    *
-   * For example, the ISO month-of-year has values from 1 to 12, which fits in an {@code int}. By
+   * For example, the ISO month-of-year has values from 1 to 12, which fits in an {@code int} . By
    * comparison, ISO nano-of-day runs from 1 to 86,400,000,000,000 which does not fit in an {@code
    * int}.
    *
-   * This implementation uses {@link #getMinimum()} and {@link #getMaximum()}.
+   * This implementation uses {@link #getMinimum()} and {@link #getMaximum()} .
    *
    * @return
-   *   true if a valid value always fits in an { @code int}
+   *   true if a valid value always fits in an {@code int}
    */
   def isIntValue: Boolean = getMinimum >= Int.MinValue && getMaximum <= Int.MaxValue
 
@@ -230,12 +230,12 @@ final class ValueRange private (
    * Checks if the value is within the valid range and that all values in the range fit in an {@code
    * int}.
    *
-   * This method combines {@link #isIntValue()} and {@link #isValidValue(long)}.
+   * This method combines {@link #isIntValue()} and {@link #isValidValue(long)} .
    *
    * @param value
    *   the value to check
    * @return
-   *   true if the value is valid and fits in an { @code int}
+   *   true if the value is valid and fits in an {@code int}
    */
   def isValidIntValue(value: Long): Boolean = isIntValue && isValidValue(value)
 
@@ -263,10 +263,10 @@ final class ValueRange private (
       value
 
   /**
-   * Checks that the specified value is valid and fits in an {@code int}.
+   * Checks that the specified value is valid and fits in an {@code int} .
    *
    * This validates that the value is within the valid range of values and that all valid values are
-   * within the bounds of an {@code int}. The field is only used to improve the error message.
+   * within the bounds of an {@code int} . The field is only used to improve the error message.
    *
    * @param value
    *   the value to check
@@ -314,7 +314,7 @@ final class ValueRange private (
   }
 
   /**
-   * Outputs this range as a {@code String}.
+   * Outputs this range as a {@code String} .
    *
    * The format will be '{min}/{largestMin} - {smallestMax}/{max}', where the largestMin or
    * smallestMax sections may be omitted, together with associated slash, if they are the same as
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala
index 4d9c4acb1..b2c5bd6c3 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala
@@ -327,7 +327,7 @@ object WeekFields {
      * Returns the week number computed from the reference day and reference dayOfWeek.
      *
      * @param offset
-     *   the offset to align a date with the start of week from { @link #startOfWeekOffset}.
+     *   the offset to align a date with the start of week from {@link #startOfWeekOffset} .
      * @param day
      *   the day for which to compute the week number
      * @return
@@ -557,11 +557,11 @@ object WeekFields {
  * aspects of a week. This class represents the definition of the week, for the purpose of providing
  * {@link TemporalField} instances.
  *
- * WeekFields provides three fields, {@link #dayOfWeek()}, {@link #weekOfMonth()}, and {@link
- * #weekOfYear()} that provide access to the values from any {@link Temporal temporal object}.
+ * WeekFields provides three fields, {@link #dayOfWeek()} , {@link #weekOfMonth()} , and {@link
+ * #weekOfYear()} that provide access to the values from any {@link Temporal temporal object} .
  *
  * The computations for day-of-week, week-of-month, and week-of-year are based on the {@link
- * ChronoField#YEAR proleptic-year}, {@link ChronoField#MONTH_OF_YEAR month-of-year}, {@link
+ * ChronoField#YEAR proleptic-year}, {@link ChronoField#MONTH_OF_YEAR month-of-year} , {@link
  * ChronoField#DAY_OF_MONTH day-of-month}, and {@link ChronoField#DAY_OF_WEEK ISO day-of-week} which
  * are based on the {@link ChronoField#EPOCH_DAY epoch-day} and the chronology. The values may not
  * be aligned with the {@link ChronoField#YEAR_OF_ERA year-of-Era} depending on the Chronology. A
@@ -609,10 +609,10 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
     throw new IllegalArgumentException("Minimal number of days is invalid")
 
   /**
-   * Returns a field to access the day of week based on this {@code WeekFields}.
+   * Returns a field to access the day of week based on this {@code WeekFields} .
    *
    * This is similar to {@link ChronoField#DAY_OF_WEEK} but uses values for the day-of-week based on
-   * this {@code WeekFields}. The days are numbered from 1 to 7 where the {@link
+   * this {@code WeekFields} . The days are numbered from 1 to 7 where the {@link
    * #getFirstDayOfWeek() first day-of-week} is assigned the value 1.
    *
    * For example, if the first day-of-week is Sunday, then that will have the value 1, with other
@@ -629,10 +629,10 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   val dayOfWeek: TemporalField = WeekFields.ComputedDayOfField.ofDayOfWeekField(this)
 
   /**
-   * Returns a field to access the week of month based on this {@code WeekFields}.
+   * Returns a field to access the week of month based on this {@code WeekFields} .
    *
    * This represents the concept of the count of weeks within the month where weeks start on a fixed
-   * day-of-week, such as Monday. This field is typically used with {@link WeekFields#dayOfWeek()}.
+   * day-of-week, such as Monday. This field is typically used with {@link WeekFields#dayOfWeek()} .
    *
    * Week one (1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are
    * at least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the month. Thus, week one may
@@ -654,15 +654,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a year, week-of-month,
    * month-of-year and day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all four fields are validated against their
+   * In {@linkplain ResolverStyle#STRICT strict mode} , all four fields are validated against their
    * range of valid values. The week-of-month field is validated to ensure that the resulting month
    * is the month requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all four fields are validated against their
+   * In {@linkplain ResolverStyle#SMART smart mode} , all four fields are validated against their
    * range of valid values. The week-of-month field is validated from 0 to 6, meaning that the
    * resulting date can be in a different month to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@linkplain ResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * four stage approach. First, create a date on the first day of the first week of January in the
    * requested year. Then take the month-of-year, subtract one, and add the amount in months to the
@@ -676,10 +676,10 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   val weekOfMonth: TemporalField = WeekFields.ComputedDayOfField.ofWeekOfMonthField(this)
 
   /**
-   * Returns a field to access the week of year based on this {@code WeekFields}.
+   * Returns a field to access the week of year based on this {@code WeekFields} .
    *
    * This represents the concept of the count of weeks within the year where weeks start on a fixed
-   * day-of-week, such as Monday. This field is typically used with {@link WeekFields#dayOfWeek()}.
+   * day-of-week, such as Monday. This field is typically used with {@link WeekFields#dayOfWeek()} .
    *
    * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are at
    * least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year. Thus, week one may start
@@ -701,15 +701,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a year, week-of-year and
    * day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are validated against their
+   * In {@linkplain ResolverStyle#STRICT strict mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated to ensure that the resulting year is
    * the year requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are validated against their
+   * In {@linkplain ResolverStyle#SMART smart mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated from 0 to 54, meaning that the
    * resulting date can be in a different year to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@linkplain ResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * three stage approach. First, create a date on the first day of the first week in the requested
    * year. Then take the week-of-year, subtract one, and add the amount in weeks to the date.
@@ -722,11 +722,11 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   val weekOfYear: TemporalField = WeekFields.ComputedDayOfField.ofWeekOfYearField(this)
 
   /**
-   * Returns a field to access the week of a week-based-year based on this {@code WeekFields}.
+   * Returns a field to access the week of a week-based-year based on this {@code WeekFields} .
    *
    * This represents the concept of the count of weeks within the year where weeks start on a fixed
    * day-of-week, such as Monday and each week belongs to exactly one year. This field is typically
-   * used with {@link WeekFields#dayOfWeek()} and {@link WeekFields#weekBasedYear()}.
+   * used with {@link WeekFields#dayOfWeek()} and {@link WeekFields#weekBasedYear()} .
    *
    * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are at
    * least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year. If the first week starts
@@ -746,15 +746,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a week-based-year, week-of-year
    * and day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are validated against their
+   * In {@linkplain ResolverStyle#STRICT strict mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated to ensure that the resulting
    * week-based-year is the week-based-year requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are validated against their
+   * In {@linkplain ResolverStyle#SMART smart mode} , all three fields are validated against their
    * range of valid values. The week-of-week-based-year field is validated from 1 to 53, meaning
    * that the resulting date can be in the following week-based-year to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@linkplain ResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * three stage approach. First, create a date on the first day of the first week in the requested
    * week-based-year. Then take the week-of-week-based-year, subtract one, and add the amount in
@@ -768,11 +768,11 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
     WeekFields.ComputedDayOfField.ofWeekOfWeekBasedYearField(this)
 
   /**
-   * Returns a field to access the year of a week-based-year based on this {@code WeekFields}.
+   * Returns a field to access the year of a week-based-year based on this {@code WeekFields} .
    *
    * This represents the concept of the year where weeks start on a fixed day-of-week, such as
    * Monday and each week belongs to exactly one year. This field is typically used with {@link
-   * WeekFields#dayOfWeek()} and {@link WeekFields#weekOfWeekBasedYear()}.
+   * WeekFields#dayOfWeek()} and {@link WeekFields#weekOfWeekBasedYear()} .
    *
    * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are at
    * least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year. Thus, week one may start
@@ -784,15 +784,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a week-based-year, week-of-year
    * and day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are validated against their
+   * In {@linkplain ResolverStyle#STRICT strict mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated to ensure that the resulting
    * week-based-year is the week-based-year requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are validated against their
+   * In {@linkplain ResolverStyle#SMART smart mode} , all three fields are validated against their
    * range of valid values. The week-of-week-based-year field is validated from 1 to 53, meaning
    * that the resulting date can be in the following week-based-year to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@linkplain ResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * three stage approach. First, create a date on the first day of the first week in the requested
    * week-based-year. Then take the week-of-week-based-year, subtract one, and add the amount in
@@ -846,7 +846,7 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
     }
 
   /**
-   * A hash code for this {@code WeekFields}.
+   * A hash code for this {@code WeekFields} .
    *
    * @return
    *   a suitable hash code
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala
index 9c35a1235..ff548b7ee 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala
@@ -52,10 +52,10 @@ package org.threeten.bp
  * to add their own units.
  *
  * A field is used to express part of a larger date-time, such as year, month-of-year or
- * second-of-minute. All fields implement {@link org.threeten.bp.temporal.TemporalField}. The set of
- * well known fields are defined in {@link org.threeten.bp.temporal.ChronoField}, for example,
- * {@link org.threeten.bp.temporal.ChronoField#HOUR_OF_DAY}. An additional fields are defined by
- * {@link org.threeten.bp.temporal.JulianFields}. The field interface is designed to allow
+ * second-of-minute. All fields implement {@link org.threeten.bp.temporal.TemporalField} . The set
+ * of well known fields are defined in {@link org.threeten.bp.temporal.ChronoField} , for example,
+ * {@link org.threeten.bp.temporal.ChronoField#HOUR_OF_DAY} . An additional fields are defined by
+ * {@link org.threeten.bp.temporal.JulianFields} . The field interface is designed to allow
  * applications to add their own fields.
  *
  * This package provides tools that allow the units and fields of date and time to be accessed in a
@@ -66,8 +66,8 @@ package org.threeten.bp
  *
  * One use of fields in application code is to retrieve fields for which there is no convenience
  * method. For example, getting the day-of-month is common enough that there is a method on {@code
- * LocalDate} called {@code getDayOfMonth()}. However for more unusual fields it is necessary to use
- * the field. For example, {@code date.get(ChronoField.ALIGNED_WEEK_OF_MONTH)}. The fields also
+ * LocalDate} called {@code getDayOfMonth()} . However for more unusual fields it is necessary to
+ * use the field. For example, {@code date.get(ChronoField.ALIGNED_WEEK_OF_MONTH)} . The fields also
  * provide access to the range of valid values.
  *
  * ==Adjustment==
@@ -75,8 +75,8 @@ package org.threeten.bp
  * A key part of the date-time problem space is adjusting a date to a new, related value, such as
  * the "last day of the month", or "next Wednesday". These are modeled as functions that adjust a
  * base date-time. The functions implement {@link org.threeten.bp.temporal.TemporalAdjuster} and
- * operate on {@link org.threeten.bp.temporal.Temporal}. A set of common functions are provided in
- * {@link org.threeten.bp.temporal.TemporalAdjusters}. For example, to find the first occurrence of
+ * operate on {@link org.threeten.bp.temporal.Temporal} . A set of common functions are provided in
+ * {@link org.threeten.bp.temporal.TemporalAdjusters} . For example, to find the first occurrence of
  * a day-of-week after a given date, use {@link
  * org.threeten.bp.temporal.TemporalAdjusters#next(DayOfWeek)}, such as {@code
  * date.with(next(MONDAY))}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala
index 0db7ee578..badff5e8d 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala
@@ -46,12 +46,12 @@ import org.threeten.bp.ZoneOffset
  * models the transition between the two offsets.
  *
  * Gaps occur where there are local date-times that simply do not not exist. An example would be
- * when the offset changes from {@code +03:00} to {@code +04:00}. This might be described as 'the
+ * when the offset changes from {@code +03:00} to {@code +04:00} . This might be described as 'the
  * clocks will move forward one hour tonight at 1am'.
  *
  * Overlaps occur where there are local date-times that exist twice. An example would be when the
- * offset changes from {@code +04:00} to {@code +03:00}. This might be described as 'the clocks will
- * move back one hour tonight at 2am'.
+ * offset changes from {@code +04:00} to {@code +03:00} . This might be described as 'the clocks
+ * will move back one hour tonight at 2am'.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  */
@@ -60,8 +60,8 @@ object ZoneOffsetTransition {
   /**
    * Obtains an instance defining a transition between two offsets.
    *
-   * Applications should normally obtain an instance from {@link ZoneRules}. This factory is only
-   * intended for use when creating {@link ZoneRules}.
+   * Applications should normally obtain an instance from {@link ZoneRules} . This factory is only
+   * intended for use when creating {@link ZoneRules} .
    *
    * @param transition
    *   the transition date-time at the transition, which never actually occurs, expressed local to
@@ -73,7 +73,7 @@ object ZoneOffsetTransition {
    * @return
    *   the transition, not null
    * @throws IllegalArgumentException
-   *   if { @code offsetBefore} and { @code offsetAfter} are equal, or { @code transition.getNano()}
+   *   if {@code offsetBefore} and {@code offsetAfter} are equal, or {@code transition.getNano()}
    *   returns non-zero value
    */
   def of(
@@ -129,8 +129,8 @@ final class ZoneOffsetTransition private[zone] (
    * This is the instant of the discontinuity, which is defined as the first instant that the
    * 'after' offset applies.
    *
-   * The methods {@link #getInstant()}, {@link #getDateTimeBefore()} and {@link #getDateTimeAfter()}
-   * all represent the same instant.
+   * The methods {@link #getInstant()} , {@link #getDateTimeBefore()} and
+   * {@link #getDateTimeAfter()} all represent the same instant.
    *
    * @return
    *   the transition instant, not null
@@ -218,7 +218,7 @@ final class ZoneOffsetTransition private[zone] (
    * Does this transition represent a gap in the local time-line.
    *
    * Gaps occur where there are local date-times that simply do not not exist. An example would be
-   * when the offset changes from {@code +01:00} to {@code +02:00}. This might be described as 'the
+   * when the offset changes from {@code +01:00} to {@code +02:00} . This might be described as 'the
    * clocks will move forward one hour tonight at 1am'.
    *
    * @return
@@ -230,7 +230,7 @@ final class ZoneOffsetTransition private[zone] (
    * Does this transition represent a gap in the local time-line.
    *
    * Overlaps occur where there are local date-times that exist twice. An example would be when the
-   * offset changes from {@code +02:00} to {@code +01:00}. This might be described as 'the clocks
+   * offset changes from {@code +02:00} to {@code +01:00} . This might be described as 'the clocks
    * will move back one hour tonight at 2am'.
    *
    * @return
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala
index f5bd3dc8b..d46d75a30 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala
@@ -46,7 +46,7 @@ import org.threeten.bp.ZoneOffset
  * ZoneOffsetTransitionRule} is used for future transitions that are based on the result of an
  * algorithm.
  *
- * The rules are loaded via {@link ZoneRulesProvider} using a {@link ZoneId}. The same rules may be
+ * The rules are loaded via {@link ZoneRulesProvider} using a {@link ZoneId} . The same rules may be
  * shared internally between multiple zone IDs.
  *
  * Serializing an instance of {@code ZoneRules} will store the entire set of rules. It does not
@@ -212,7 +212,7 @@ abstract class ZoneRules private[zone] () {
    * Since, in the case of Gap and Overlap, the offset returned is a "best" value, rather than the
    * "correct" value, it should be treated with care. Applications that care about the correct
    * offset should use a combination of this method, {@link #getValidOffsets(LocalDateTime)} and
-   * {@link #getTransition(LocalDateTime)}.
+   * {@link #getTransition(LocalDateTime)} .
    *
    * @param localDateTime
    *   the local date-time to query, not null, but null may be ignored if the rules have a single
@@ -237,7 +237,7 @@ abstract class ZoneRules private[zone] () {
    * offsets, which is a list of size 0, 1 or 2. In the case where there are two offsets, the
    * earlier offset is returned at index 0 and the later offset at index 1.
    *
-   * There are various ways to handle the conversion from a {@code LocalDateTime}. One technique,
+   * There are various ways to handle the conversion from a {@code LocalDateTime} . One technique,
    * using this method, would be: <pre> List<ZoneOffset> validOffsets = rules.getOffset(localDT); if
    * (validOffsets.size() == 1) { // Normal case: only one valid offset zoneOffset =
    * validOffsets.get(0); } else { // Gap or Overlap: determine what to do from transition (which
@@ -269,7 +269,7 @@ abstract class ZoneRules private[zone] () {
    * local date-time values with two valid offsets.</li> </ul><p> A transition is used to model the
    * cases of a Gap or Overlap. The Normal case will return null.
    *
-   * There are various ways to handle the conversion from a {@code LocalDateTime}. One technique,
+   * There are various ways to handle the conversion from a {@code LocalDateTime} . One technique,
    * using this method, would be: <pre> ZoneOffsetTransition trans = rules.getTransition(localDT);
    * if (trans == null) { // Gap or Overlap: determine what to do from transition } else { // Normal
    * case: only one valid offset zoneOffset = rule.getOffset(localDT); } </pre>
@@ -395,9 +395,9 @@ abstract class ZoneRules private[zone] () {
    * #getTransitions()}. This method returns instances of {@link ZoneOffsetTransitionRule} that
    * define an algorithm for when transitions will occur.
    *
-   * For any given {@code ZoneRules}, this list contains the transition rules for years beyond those
-   * years that have been fully defined. These rules typically refer to future daylight saving time
-   * rule changes.
+   * For any given {@code ZoneRules} , this list contains the transition rules for years beyond
+   * those years that have been fully defined. These rules typically refer to future daylight saving
+   * time rule changes.
    *
    * If the zone defines daylight savings into the future, then the list will normally be of size
    * two and hold information about entering and exiting daylight savings. If the zone does not have
@@ -429,7 +429,7 @@ abstract class ZoneRules private[zone] () {
   override def equals(otherRules: Any): Boolean
 
   /**
-   * Returns a suitable hash code given the definition of {@code #equals}.
+   * Returns a suitable hash code given the definition of {@code #equals} .
    *
    * @return
    *   the hash code
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala
index 91cbd3db2..83a63c8ff 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala
@@ -64,7 +64,7 @@ import org.threeten.bp.chrono.IsoChronology
  * windows can have the same standard offset.
  *
  * Within each window, there can either be a {@link #setFixedSavingsToWindow fixed savings amount}
- * or a {@link #addRuleToWindow list of rules}.
+ * or a {@link #addRuleToWindow list of rules} .
  */
 class ZoneRulesBuilder() {
 
@@ -553,7 +553,7 @@ class ZoneRulesBuilder() {
      *   the month of the transition, not null
      * @param dayOfMonthIndicator
      *   the day-of-month of the transition, adjusted by dayOfWeek, from 1 to 31 adjusted later, or
-     * -1 to -28 adjusted earlier from the last day of the month
+     *   -1 to -28 adjusted earlier from the last day of the month
      * @param dayOfWeek
      *   the day-of-week to adjust to, null if day-of-month should not be adjusted
      * @param time
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala
index 5a40c806c..94ea357fa 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala
@@ -36,7 +36,7 @@ import java.util.concurrent.atomic.AtomicReference
 
 /**
  * Controls how the time-zone rules are initialized. <p> The default behavior is to use {@link
- * ServiceLoader} to find instances of {@link ZoneRulesProvider}. Use the {@link
+ * ServiceLoader} to find instances of {@link ZoneRulesProvider} . Use the {@link
  * #setInitializer(ZoneRulesInitializer)} method to replace this behavior. The initializer instance
  * must perform the work of creating the {@code ZoneRulesProvider} within the {@link
  * #initializeProviders()} method to ensure that the provider is not initialized too early. <p>
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala
index 5aca943c8..bea5ea575 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala
@@ -49,7 +49,7 @@ object ZoneRulesProvider {
   /**
    * Gets the set of available zone IDs.
    *
-   * These zone IDs are loaded and available for use by {@code ZoneId}.
+   * These zone IDs are loaded and available for use by {@code ZoneId} .
    *
    * @return
    *   the unmodifiable copy of the set of zone IDs, not null
@@ -62,22 +62,22 @@ object ZoneRulesProvider {
    * This returns the latest available rules for the zone ID.
    *
    * This method relies on time-zone data provider files that are configured. These are loaded using
-   * a {@code ServiceLoader}.
+   * a {@code ServiceLoader} .
    *
    * The caching flag is designed to allow provider implementations to prevent the rules being
-   * cached in {@code ZoneId}. Under normal circumstances, the caching of zone rules is highly
+   * cached in {@code ZoneId} . Under normal circumstances, the caching of zone rules is highly
    * desirable as it will provide greater performance. However, there is a use case where the
-   * caching would not be desirable, see {@link #provideRules}.
+   * caching would not be desirable, see {@link #provideRules} .
    *
    * @param zoneId
-   *   the zone ID as defined by { @code ZoneId}, not null
+   *   the zone ID as defined by {@code ZoneId} , not null
    * @param forCaching
    *   whether the rules are being queried for caching, true if the returned rules will be cached by
-   *   { @code ZoneId}, false if they will be returned to the user without being cached in { @code
+   *   {@code ZoneId} , false if they will be returned to the user without being cached in { @code
    *   ZoneId}
    * @return
-   *   the rules, null if { @code forCaching} is true and this is a dynamic provider that wants to
-   *   prevent caching in { @code ZoneId}, otherwise not null
+   *   the rules, null if {@code forCaching} is true and this is a dynamic provider that wants to
+   *   prevent caching in {@code ZoneId} , otherwise not null
    * @throws ZoneRulesException
    *   if rules cannot be obtained for the zone ID
    */
@@ -103,7 +103,7 @@ object ZoneRulesProvider {
    * more than one element if historical rule information is available.
    *
    * @param zoneId
-   *   the zone region ID as used by { @code ZoneId}, not null
+   *   the zone region ID as used by {@code ZoneId} , not null
    * @return
    *   a modifiable copy of the history of the rules for the ID, sorted from oldest to newest, not
    *   null
@@ -119,7 +119,7 @@ object ZoneRulesProvider {
    * Gets the provider for the zone ID.
    *
    * @param zoneId
-   *   the zone region ID as used by { @code ZoneId}, not null
+   *   the zone region ID as used by {@code ZoneId} , not null
    * @return
    *   the provider, not null
    * @throws ZoneRulesException
@@ -141,7 +141,7 @@ object ZoneRulesProvider {
    *
    * This adds a new provider to those currently available. A provider supplies rules for one or
    * more zone IDs. A provider cannot be registered if it supplies a zone ID that has already been
-   * registered. See the notes on time-zone IDs in {@link ZoneId}, especially the section on using
+   * registered. See the notes on time-zone IDs in {@link ZoneId} , especially the section on using
    * the concept of a "group" to make IDs unique.
    *
    * To ensure the integrity of time-zones already created, there is no way to deregister providers.
@@ -214,7 +214,7 @@ object ZoneRulesProvider {
  * API that can be used to manage the providers. The abstract methods provide the SPI that allows
  * rules to be provided.
  *
- * Rules are looked up primarily by zone ID, as used by {@link ZoneId}. Only zone region IDs may be
+ * Rules are looked up primarily by zone ID, as used by {@link ZoneId} . Only zone region IDs may be
  * used, zone offset IDs are not used here.
  *
  * Time-zone rules are political, thus the data can change at any time. Each provider will provide
@@ -281,7 +281,7 @@ abstract class ZoneRulesProvider protected () {
    * provider may increase the set of versions as more data becomes available.
    *
    * @param zoneId
-   *   the zone region ID as used by { @code ZoneId}, not null
+   *   the zone region ID as used by {@code ZoneId} , not null
    * @return
    *   a modifiable copy of the history of the rules for the ID, sorted from oldest to newest, not
    *   null
diff --git a/tests/shared/src/test/scala-2/org/threeten/bp/temporal/MockFieldNoValue.scala b/tests/shared/src/test/scala-2/org/threeten/bp/temporal/MockFieldNoValue.scala
index e1739cabb..204f7875c 100644
--- a/tests/shared/src/test/scala-2/org/threeten/bp/temporal/MockFieldNoValue.scala
+++ b/tests/shared/src/test/scala-2/org/threeten/bp/temporal/MockFieldNoValue.scala
@@ -45,18 +45,18 @@ object MockFieldNoValue {
 final class MockFieldNoValue(name: String, ordinal: Int)
     extends Enum[MockFieldNoValue](name, ordinal)
     with TemporalField {
-  override def toString: String  = null
-  def getBaseUnit: TemporalUnit  = WEEKS
-  def getRangeUnit: TemporalUnit = MONTHS
-  def range: ValueRange          = ValueRange.of(1, 20)
-  def isDateBased: Boolean       = true
-  def isTimeBased: Boolean       = false
-  def isSupportedBy(dateTime:  TemporalAccessor): Boolean    = true
-  def rangeRefinedBy(dateTime: TemporalAccessor): ValueRange = ValueRange.of(1, 20)
-  def getFrom(dateTime:        TemporalAccessor): Long       = throw new DateTimeException("Mock")
-  def adjustInto[R <: Temporal](dateTime: R, newValue: Long): R =
+  override def toString: String                                        = null
+  def getBaseUnit: TemporalUnit                                        = WEEKS
+  def getRangeUnit: TemporalUnit                                       = MONTHS
+  def range: ValueRange                                                = ValueRange.of(1, 20)
+  def isDateBased: Boolean                                             = true
+  def isTimeBased: Boolean                                             = false
+  def isSupportedBy(dateTime:         TemporalAccessor): Boolean       = true
+  def rangeRefinedBy(dateTime:        TemporalAccessor): ValueRange    = ValueRange.of(1, 20)
+  def getFrom(dateTime:               TemporalAccessor): Long          = throw new DateTimeException("Mock")
+  def adjustInto[R <: Temporal](dateTime: R, newValue: Long): R        =
     throw new DateTimeException("Mock")
-  override def getDisplayName(locale: Locale): String = "Mock"
+  override def getDisplayName(locale: Locale): String                  = "Mock"
   override def resolve(
     fieldValues:     java.util.Map[TemporalField, java.lang.Long],
     partialTemporal: TemporalAccessor,
diff --git a/tests/shared/src/test/scala-3/org/threeten/bp/temporal/MockFieldNoValue.scala b/tests/shared/src/test/scala-3/org/threeten/bp/temporal/MockFieldNoValue.scala
index 47b01e282..44c9e13c2 100644
--- a/tests/shared/src/test/scala-3/org/threeten/bp/temporal/MockFieldNoValue.scala
+++ b/tests/shared/src/test/scala-3/org/threeten/bp/temporal/MockFieldNoValue.scala
@@ -42,18 +42,18 @@ enum MockFieldNoValue private (name: String, ordinal: Int)
     extends Enum[MockFieldNoValue]
     with TemporalField {
   case INSTANCE extends MockFieldNoValue("INSTANCE", 0)
-  override def toString: String  = null
-  def getBaseUnit: TemporalUnit  = WEEKS
-  def getRangeUnit: TemporalUnit = MONTHS
-  def range: ValueRange          = ValueRange.of(1, 20)
-  def isDateBased: Boolean       = true
-  def isTimeBased: Boolean       = false
-  def isSupportedBy(dateTime:  TemporalAccessor): Boolean    = true
-  def rangeRefinedBy(dateTime: TemporalAccessor): ValueRange = ValueRange.of(1, 20)
-  def getFrom(dateTime:        TemporalAccessor): Long       = throw new DateTimeException("Mock")
-  def adjustInto[R <: Temporal](dateTime: R, newValue: Long): R =
+  override def toString: String                                        = null
+  def getBaseUnit: TemporalUnit                                        = WEEKS
+  def getRangeUnit: TemporalUnit                                       = MONTHS
+  def range: ValueRange                                                = ValueRange.of(1, 20)
+  def isDateBased: Boolean                                             = true
+  def isTimeBased: Boolean                                             = false
+  def isSupportedBy(dateTime:         TemporalAccessor): Boolean       = true
+  def rangeRefinedBy(dateTime:        TemporalAccessor): ValueRange    = ValueRange.of(1, 20)
+  def getFrom(dateTime:               TemporalAccessor): Long          = throw new DateTimeException("Mock")
+  def adjustInto[R <: Temporal](dateTime: R, newValue: Long): R        =
     throw new DateTimeException("Mock")
-  override def getDisplayName(locale: Locale): String = "Mock"
+  override def getDisplayName(locale: Locale): String                  = "Mock"
   override def resolve(
     fieldValues:     java.util.Map[TemporalField, java.lang.Long],
     partialTemporal: TemporalAccessor,
diff --git a/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala b/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala
index 2961d4963..0b62baf4e 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala
@@ -17,27 +17,27 @@ trait AssertionsHelper { this: AnyFunSuite =>
       true
 
   def assertEquals[A, B](
-    o1:                  A,
-    o2:                  B,
-    msg:                 String
+    o1:  A,
+    o2:  B,
+    msg: String
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 == o2, msg)
 
   def assertEquals[A, B](
-    o1:                  A,
-    o2:                  B
+    o1: A,
+    o2: B
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 == o2)
 
   def assertSame[A <: AnyRef, B <: AnyRef](
-    o1:                  A,
-    o2:                  B
+    o1: A,
+    o2: B
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 eq o2)
 
   def assertNotEquals[A, B](
-    o1:                  A,
-    o2:                  B
+    o1: A,
+    o2: B
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 != o2)
 
@@ -51,8 +51,8 @@ trait AssertionsHelper { this: AnyFunSuite =>
     assert(a == null)
 
   def assertNotNull[A](
-    a:                   A,
-    msg:                 String
+    a:   A,
+    msg: String
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(a != null, msg)
 
diff --git a/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala b/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala
index fb35fbcfe..cddcc3718 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala
@@ -54,9 +54,9 @@ object MockSimplePeriod {
    * @param unit
    *   the unit that the period is measured in, must not be the 'Forever' unit, not null
    * @return
-   *   the { @code MockSimplePeriod} instance, not null
+   *   the {@code MockSimplePeriod} instance, not null
    * @throws DateTimeException
-   *   if the period unit is { @link org.threeten.bp.temporal.ChronoUnit#FOREVER}.
+   *   if the period unit is {@link org.threeten.bp.temporal.ChronoUnit#FOREVER} .
    */
   def of(amount: Long, unit: TemporalUnit): MockSimplePeriod = new MockSimplePeriod(amount, unit)
 }
diff --git a/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala b/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala
index b263dbb18..f7ba88da0 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala
@@ -244,27 +244,27 @@ class TestInstant
       List[Long](Long.MaxValue - 1,
                  0,
                  (Long.MaxValue - 1) / 1000,
-                 ((Long.MaxValue - 1) % 1000).toInt * 1000000
+                 ((Long.MaxValue - 1)                                   % 1000).toInt * 1000000
       ),
       List[Long](Long.MinValue,
                  0,
                  (Long.MinValue / 1000) - 1,
-                 (Long.MinValue % 1000).toInt * 1000000 + 1000000000
+                 (Long.MinValue                                         % 1000).toInt * 1000000 + 1000000000
       ),
       List[Long](Long.MinValue,
                  1,
                  (Long.MinValue / 1000) - 1,
-                 (Long.MinValue % 1000).toInt * 1000000 + 1000000000 + 1
+                 (Long.MinValue                                         % 1000).toInt * 1000000 + 1000000000 + 1
       ),
       List[Long](Long.MinValue + 1,
                  0,
                  ((Long.MinValue + 1) / 1000) - 1,
-                 ((Long.MinValue + 1) % 1000).toInt * 1000000 + 1000000000
+                 ((Long.MinValue + 1)                                   % 1000).toInt * 1000000 + 1000000000
       ),
       List[Long](Long.MinValue + 1,
                  1,
                  ((Long.MinValue + 1) / 1000) - 1,
-                 ((Long.MinValue + 1) % 1000).toInt * 1000000 + 1000000000 + 1
+                 ((Long.MinValue + 1)                                   % 1000).toInt * 1000000 + 1000000000 + 1
       )
     )
 
@@ -730,7 +730,7 @@ class TestInstant
            0,
            Long.MinValue,
            Long.MinValue / 1000 - 1,
-           (Long.MinValue % 1000).toInt * 1000000 + 1000000000
+           (Long.MinValue                                            % 1000).toInt * 1000000 + 1000000000
       )
     )
 
diff --git a/tests/shared/src/test/scala/org/threeten/bp/TestLocalDateTime.scala b/tests/shared/src/test/scala/org/threeten/bp/TestLocalDateTime.scala
index 94890e088..a048e172f 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/TestLocalDateTime.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/TestLocalDateTime.scala
@@ -1632,7 +1632,7 @@ class TestLocalDateTime
       while (i < 50) {
         {
           t = t.plusHours(1)
-          if ((i + 1)                     % 24 == 0)
+          if ((i + 1) % 24 == 0)
             d = d.plusDays(1)
           assertEquals(t.toLocalDate, d)
           assertEquals(t.getHour, (i + 1) % 24)
@@ -2308,7 +2308,7 @@ class TestLocalDateTime
       while (i < 50) {
         {
           t = t.minusHours(1)
-          if (i                               % 24 == 0)
+          if (i % 24 == 0)
             d = d.minusDays(1)
           assertEquals(t.toLocalDate, d)
           assertEquals(t.getHour, (((-i + 23) % 24) + 24) % 24)
diff --git a/tests/shared/src/test/scala/org/threeten/bp/format/GenTestPrinterParser.scala b/tests/shared/src/test/scala/org/threeten/bp/format/GenTestPrinterParser.scala
index fcca0dfab..20a49c119 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/format/GenTestPrinterParser.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/format/GenTestPrinterParser.scala
@@ -48,9 +48,9 @@ import org.threeten.bp.format.internal.TTBPDateTimePrintContext
 /** Abstract PrinterParser test. */
 object GenTestPrinterParser {
   private val EMPTY: TemporalAccessor = new TemporalAccessor() {
-    def isSupported(field: TemporalField): Boolean = true
-    def getLong(field:     TemporalField): Long    = throw new DateTimeException("Mock")
-    override def get(field: TemporalField): Int =
+    def isSupported(field:       TemporalField): Boolean    = true
+    def getLong(field:           TemporalField): Long       = throw new DateTimeException("Mock")
+    override def get(field: TemporalField): Int             =
       range(field).checkValidIntValue(getLong(field), field)
     override def query[R](query: TemporalQuery[R]): R       = query.queryFrom(this)
     override def range(field:    TemporalField): ValueRange = field.range

From f2c6dee001b6d1fee9f0c7ac5e6ba20d23facb53 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Thu, 7 Nov 2024 14:54:39 +0000
Subject: [PATCH 3/3] Add 'Reformat with scalafmt 3.8.3' to
 .git-blame-ignore-revs

---
 .git-blame-ignore-revs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index f6f1e649e..9892096ec 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -3,3 +3,6 @@ aa7db3a42121f78a5b3bed3658786c1cef83efe8
 
 # Enable scalafmt for Scala 3
 64df4ae51873593a789af5848bd225c14d0baf8a
+
+# Scala Steward: Reformat with scalafmt 3.8.3
+45112b9ff729c0b774bed69b9d1bcaa99e3873f4