Update to kantan.sbt 2.8.2

core/shared/src/main/scala/kantan/codecs/export/package.scala

@@ -26,7 +26,7 @@ package kantan.codecs
   * rather than [[Decoder]] / [[Encoder]], however, they'll find themselves with a lower precedence and only be used
   * if no other, more specific instance is found.
   */
-package object export {
+package object `export` {
 
   /** [[Decoder]] instance that should only be used when no specific one is found. */
   type DerivedDecoder[E, D, F, T] = Exported[Decoder[E, D, F, T]]

enumeratum/core/shared/src/main/scala/kantan/codecs/enumeratum/EnumInstances.scala

@@ -25,14 +25,14 @@ import scala.annotation.nowarn
 trait DecoderInstances {
 
   implicit def enumeratumDecoder[E, D <: EnumEntry, F, T](
-    implicit enum: Enum[D],
+    implicit enumD: Enum[D],
     decoder: Decoder[E, String, F, T],
     error: IsError[F]
   ): Decoder[E, D, F, T] = {
     // Enum is not serializable. The following is to make sure that the generated Decoder doesn't embark a
     // non-serializable value and becomes non-serializable itself.
-    val map       = enum.namesToValuesMap
-    val enumLabel = enum.values.map(_.entryName).mkString("[", ", ", "]")
+    val map       = enumD.namesToValuesMap
+    val enumLabel = enumD.values.map(_.entryName).mkString("[", ", ", "]")
 
     decoder.emap { name =>
       map.get(name).toRight(error.fromMessage(s"'$name' is not a member of enumeration $enumLabel"))

enumeratum/core/shared/src/main/scala/kantan/codecs/enumeratum/values/ValueEnumInstances.scala

@@ -30,14 +30,14 @@ trait DecoderInstances {
 
   @SuppressWarnings(Array("org.wartremover.warts.StringPlusAny"))
   def enumeratumDecoder[V, E, D <: ValueEnumEntry[V], F, T](
-    implicit enum: ValueEnum[V, D],
+    implicit valueEnum: ValueEnum[V, D],
     decoder: Decoder[E, V, F, T],
     error: IsError[F]
   ): Decoder[E, D, F, T] = {
     // ValueEnum is not serializable. The following is to make sure that the generated Decoder doesn't embark a
     // non-serializable value and becomes non-serializable itself.
-    val map       = enum.valuesToEntriesMap
-    val enumLabel = enum.values.map(_.value).mkString("[", ", ", "]")
+    val map       = valueEnum.valuesToEntriesMap
+    val enumLabel = valueEnum.values.map(_.value).mkString("[", ", ", "]")
 
     decoder.emap { value =>
       map.get(value).toRight(error.fromMessage(s"'$value' is not in values $enumLabel"))

enumeratum/laws/shared/src/main/scala/kantan/codecs/enumeratum/laws/discipline/arbitrary.scala

@@ -43,18 +43,18 @@ trait ArbitraryInstances
   // -------------------------------------------------------------------------------------------------------------------
 
   def arbLegalEnumeratedValue[V: StringEncoder, A <: ValueEnumEntry[V]](
-    enum: ValueEnum[V, A]
+    valueEnum: ValueEnum[V, A]
   ): Arbitrary[LegalString[A]] =
     Arbitrary(
       Gen.oneOf(
-        enum.values.map(v => LegalValue[String, A, codecs.type](StringEncoder[V].encode(v.value), v))
+        valueEnum.values.map(v => LegalValue[String, A, codecs.type](StringEncoder[V].encode(v.value), v))
       )
     )
 
   def arbIllegalEnumeratedValue[V: StringEncoder, A <: ValueEnumEntry[V]](
-    enum: ValueEnum[V, A]
+    valueEnum: ValueEnum[V, A]
   ): Arbitrary[IllegalValue[String, A, codecs.type]] = {
-    val legal = enum.values.map(a => StringEncoder[V].encode(a.value))
+    val legal = valueEnum.values.map(a => StringEncoder[V].encode(a.value))
     Arbitrary {
       arb[String].suchThat(s => !legal.contains(s)).map(s => IllegalValue(s))
     }

project/plugins.sbt

@@ -1,2 +1,2 @@
-addSbtPlugin("com.nrinaudo" % "kantan.sbt-kantan"  % "2.8.1")
-addSbtPlugin("com.nrinaudo" % "kantan.sbt-scalajs" % "2.8.1")
+addSbtPlugin("com.nrinaudo" % "kantan.sbt-kantan"  % "2.8.2")
+addSbtPlugin("com.nrinaudo" % "kantan.sbt-scalajs" % "2.8.2")