switch to signed-first approach

It turns out signed math is more performant

src/commonMain/kotlin/com/infendro/bytes/bytearray/Operators.kt

@@ -1,16 +1,57 @@
 package com.infendro.bytes.bytearray
 
-import com.infendro.bytes.ubytearray.*
+import kotlin.experimental.and
+import kotlin.experimental.inv
+import kotlin.experimental.or
+import kotlin.experimental.xor
 
 fun ByteArray.invInto(
     destination: ByteArray,
     destinationOffset: Int = 0,
     startIndex: Int = 0,
     endIndex: Int = size,
-) = asUByteArray().invInto(destination.asUByteArray(), destinationOffset, startIndex, endIndex)
+) {
+    val length = endIndex - startIndex
+    require(length >= 0)
+    require(startIndex in 0..(size - length))
+    require(destinationOffset in 0..(destination.size - length))
+
+    repeat(length) { i ->
+        destination[destinationOffset + i] = this[startIndex + i].inv()
+    }
+}
 
 fun ByteArray.inv() =
-    (asUByteArray().inv()).asByteArray()
+    ByteArray(size).also { invInto(it) }
+
+private inline fun ByteArray.combineInto(
+    that: ByteArray,
+    destination: ByteArray,
+    destinationOffset: Int = 0,
+    startIndex: Int = 0,
+    endIndex: Int = size,
+    thatStartIndex: Int = 0,
+    combine: (Byte, Byte) -> Byte,
+) {
+    val length = endIndex - startIndex
+    require(length >= 0)
+    require(startIndex in 0..(size - length))
+    require(thatStartIndex in 0..(that.size - length))
+    require(destinationOffset in 0..(destination.size - length))
+
+    repeat(length) { i ->
+        destination[destinationOffset + i] = combine(this[startIndex + i], that[thatStartIndex + i])
+    }
+}
+
+private inline fun ByteArray.combine(
+    that: ByteArray,
+    combine: (Byte, Byte) -> Byte,
+): ByteArray {
+    require(this.size == that.size)
+
+    return ByteArray(size).also { combineInto(that, it, combine = combine) }
+}
 
 fun ByteArray.andInto(
     that: ByteArray,
@@ -19,17 +60,10 @@ fun ByteArray.andInto(
     startIndex: Int = 0,
     endIndex: Int = size,
     thatStartIndex: Int = 0,
-) = asUByteArray().andInto(
-    that.asUByteArray(),
-    destination.asUByteArray(),
-    destinationOffset,
-    startIndex,
-    endIndex,
-    thatStartIndex,
-)
+) = combineInto(that, destination, destinationOffset, startIndex, endIndex, thatStartIndex) { a, b -> a and b }
 
 infix fun ByteArray.and(that: ByteArray) =
-    (this.asUByteArray() and that.asUByteArray()).asByteArray()
+    combine(that) { a, b -> a and b }
 
 fun ByteArray.orInto(
     that: ByteArray,
@@ -38,17 +72,10 @@ fun ByteArray.orInto(
     startIndex: Int = 0,
     endIndex: Int = size,
     thatStartIndex: Int = 0,
-) = asUByteArray().orInto(
-    that.asUByteArray(),
-    destination.asUByteArray(),
-    destinationOffset,
-    startIndex,
-    endIndex,
-    thatStartIndex,
-)
+) = combineInto(that, destination, destinationOffset, startIndex, endIndex, thatStartIndex) { a, b -> a or b }
 
 infix fun ByteArray.or(that: ByteArray) =
-    (this.asUByteArray() or that.asUByteArray()).asByteArray()
+    combine(that) { a, b -> a or b }
 
 fun ByteArray.xorInto(
     that: ByteArray,
@@ -57,14 +84,7 @@ fun ByteArray.xorInto(
     startIndex: Int = 0,
     endIndex: Int = size,
     thatStartIndex: Int = 0,
-) = asUByteArray().xorInto(
-    that.asUByteArray(),
-    destination.asUByteArray(),
-    destinationOffset,
-    startIndex,
-    endIndex,
-    thatStartIndex,
-)
+) = combineInto(that, destination, destinationOffset, startIndex, endIndex, thatStartIndex) { a, b -> a xor b }
 
 infix fun ByteArray.xor(that: ByteArray) =
-    (this.asUByteArray() xor that.asUByteArray()).asByteArray()
+    combine(that) { a, b -> a xor b }