split padding in StreamEncoding to PaddedStreamEncoding

src/commonMain/kotlin/com/infendro/encoding/StreamEncoding.kt

@@ -1,30 +1,17 @@
 package com.infendro.encoding
 
 import com.infendro.encoding.exception.IllegalByteException
-import com.infendro.encoding.util.align
 import com.infendro.encoding.util.divCeil
-import com.infendro.encoding.util.lcm
 import com.infendro.encoding.util.log2
 
 class StreamEncoding internal constructor(
     override val alphabet: ByteArray,
-    private val padding: Byte? = null,
 ) : Encoding {
-    init {
-        require(base and (base - 1) == 0)
-    }
-
     override fun encode(bytes: ByteArray): ByteArray {
         val bits = log2(base).toInt()
+
         val size = (bytes.size * 8).divCeil(bits)
-        val encodedSize = when (padding) {
-            null -> size
-            else -> {
-                val block = lcm(bits, 8) / bits
-                size.align(block)
-            }
-        }
-        val result = ByteArray(encodedSize)
+        val result = ByteArray(size)
 
         var r = 0
         var buffer = 0
@@ -43,15 +30,8 @@ class StreamEncoding internal constructor(
             }
         }
         if (bufferBits > 0) {
-            buffer = buffer shl (bits - bufferBits)
-            val index = buffer
-            result[r++] = alphabet[index]
-        }
-
-        if (padding != null) {
-            while (r < result.size) {
-                result[r++] = padding
-            }
+            val index = buffer shl (bits - bufferBits)
+            result[r] = alphabet[index]
         }
 
         return result
@@ -59,24 +39,20 @@ class StreamEncoding internal constructor(
 
     override fun decode(bytes: ByteArray): ByteArray {
         val bits = log2(base).toInt()
-        val index = padding?.let { bytes.indexOf(it) } ?: -1
-        val decodedSize = when (index) {
-            -1 -> bytes.size * bits / 8
-            else -> index * bits / 8
-        }
-        val result = ByteArray(decodedSize)
+
+        val size = bytes.size * bits / 8
+        val result = ByteArray(size)
 
         var r = 0
         var buffer = 0
         var bufferBits = 0
         for (i in bytes.indices) {
             val byte = bytes[i]
-            if (byte == padding) break
 
-            val index = alphabet.indexOf(byte)
-            if (index == -1) throw IllegalByteException(byte)
+            val value = alphabet.indexOf(byte)
+            if (value == -1) throw IllegalByteException(byte)
 
-            buffer = (buffer shl bits) + index.toByte()
+            buffer = (buffer shl bits) + value.toByte()
             bufferBits += bits
 
             if (bufferBits >= 8) {